mruby-regexp: ask the byte cases of a byte-indexed subject alone - #7120

Third of the pieces #7110 was split into, on top of #7115 and #7116, and test
only. Deleting assertions deserves its own pull request rather than a paragraph
inside one that changes behaviour, so here it is on its own.

Each of these cases asks what the engine does with a byte that stands for no
character, and since #7115 and #7116 it asks twice: once through a subject read
as UTF-8 that carries the byte, and once through a byte-indexed subject.

Only one of the two subjects can answer

Read as UTF-8, the subject spells no character where that byte is. What a
quantifier binds to there, whether a class holds the byte, and where a match may
start are then answers about a decoder walking input no rule covers.

Byte-indexed, the same byte is a byte from end to end, every position reported is
a byte offset the subject's own indexing agrees with, and the engine reaches it
through the branch it keeps for exactly that: mrb_re_charlen() and
mrb_re_decode_char() advance a byte at a time, and the seeding guard skips
mrb_re_utf8_interior_p(), so no position is the interior of anything.

What this does

Drops the UTF-8 subject from those cases and keeps the byte-indexed one. The
comment that explained each case moves to the assertion that still makes it,
which is most of what the diff shows as added.

Nothing a whole UTF-8 subject can ask is touched:

• a match position inside a character ("あ".match(Regexp.new("\x81")) and the
  "ĵ" cases) keeps its subject
• a class that holds a character rather than a byte (mu =~ /[\xB5]/ and the
  \u{B5} spellings) keeps its subject
• the pattern side of an overlong sequence
  (Regexp.new("[\xC0\xBC]").match?("<")) keeps its subject
• Regexp - match positions on malformed UTF-8 agree with string indexing is
  left exactly as it is: what it pins is what mruby knows about the string
  rather than what the engine does with the bytes, so it belongs with the piece
  that changes its answer

The fuzz-derived buffer cases (Regexp - invalid UTF-8 byte near pattern end
and Regexp - truncated UTF-8 at subject end) keep a walk to the end of each
buffer, in the byte-indexed form #7116 added.

Verified

• rake test on a full-core build (MRB_UTF8_STRING through mruby-encoding):
  2253 tests, all green
• rake test on the default gembox (no MRB_UTF8_STRING): 2060 tests, all
  green
• prek run --all-files passes, except that markdownlint could not install
  locally (npm engine mismatch); no Markdown is touched here

Summary by CodeRabbit

• Tests
  • Expanded UTF-8 regular expression coverage for malformed, truncated, overlong, and invalid sequences.
  • Added validation for byte-based match positions, extraction offsets, character classes, and quantifier boundaries.
  • Improved coverage of decoding boundaries in both patterns and input text.