mruby-regexp: exempt a quoted String pattern from the subject check - #7127

CRuby raises `ArgumentError` when a search is given a subject holding a byte
that spells no character. mruby answered for it instead, so the same program
took a result CRuby would not have produced:

```ruby
"あ\x80b" =~ /b/         # CRuby: ArgumentError, mruby: 2
"あ\x80b".scan(/./)      # CRuby: ArgumentError, mruby: ["あ", "\x80", "b"]
"\xC0\xBC" =~ /[^<]/     # CRuby: ArgumentError, mruby: 0
```

Follow CRuby wherever a search reads the subject: `=~`, `match`, `match?`,
`===`, `index`, `rindex`, `byteindex`, `byterindex`, `[]`, `[]=`, `sub`, `sub!`,
`gsub`, `gsub!`, `scan`, `split`, `partition`, `rpartition`, `start_with?` and
`slice!`. `String#scrub` is how a subject like this becomes matchable.

A binary string goes through untouched, since it is indexed by byte from end to
end and its bytes make no claim that could be broken. A string derived from a
binary one does not carry `MRB_STR_BINARY` with it, so `b + ""` and `b.sub(...)`
are refused where `b` itself is not; that gap predates this change and is left
as it is.

A quoted String pattern is refused here as well, where CRuby answers for it.
CRuby searches for a literal byte by byte and reads the subject as UTF-8 nowhere
along the way, so

```ruby
"あ\x80b".sub("b", "!")  # CRuby: "あ\x80!", here: ArgumentError
```

Exempting it means carrying the fact that the pattern was a literal from `sub`
down to the search it makes, which `sub!` and `gsub!` pay for by quoting the
pattern twice, so that is a change of its own and comes next. `scan` needs none
of it: CRuby refuses a literal there too.

The check goes in each search rather than at the entry to the methods that drive
one, because core remembers a string it has read as valid UTF-8. Most of the
entry points here search once for what arrives from Ruby, but `__byte_search`,
which the mrblib loops of `gsub`, `split` and `byteindex` drive, is called once
per match, and `__regexp_rsearch` steps `__search` over every match position.
Those turns read the flag core left on the subject after the first one, so what
they cost is a flag test and not a walk. The flag `String#length` leaves behind
cannot stand in for it, since a string of stray bytes has one byte per character
too, which is why only the walk decides.

What a subject nothing has walked yet pays is one walk. It skips a run of ASCII
a word at a time and decodes only where a byte leaves that range, so the cost
follows how much of the subject is multi-byte. At `-O3` on a full-core build,
the fastest of fifteen runs each, with `mb` for `"あ" * 100000` and `cs` for
`"あ," * 20000`:

| | before | after |
|---|---|---|
| `(mb + "z") =~ /z/`, 200 times, less the cost of building the subjects | 52.1 ms | 103.8 ms |
| the same with an ASCII subject of the same byte size | 1.2 ms | 0.7 ms |
| `"hello world" =~ /world/`, 100000 times | 133.6 ms | 133.0 ms |
| `cs.split(/,/)`, one walk and 20000 searches | 71.1 ms | 61.4 ms |
| `cs.gsub(/,/) { ";" }`, the same | 75.1 ms | 72.9 ms |
| `cs.rindex(/,/)`, one walk and 20000 match positions | 2105.9 ms | 2114.6 ms |

The first row builds a subject for every search so that every search walks one.
The rest reuse a subject, which is why the loop rows show what the flag costs
rather than what the walk does, and they and the ASCII row are inside the noise
of the machine they were taken on.

A `pos` outside the subject still answers nil rather than raising, since
`re_char_to_byte()` rejects it before the check runs. `String#index` answers nil
for one in CRuby too; `Regexp#match` raises there, where this answers nil.
`rindex` clamps a position past the end to the end rather than rejecting it, so
it reaches the check and refuses, which is what CRuby answers as well.

Most of the tests that ask what the engine does with a byte standing for no
character already put the question to a byte-indexed subject, so this refuses
none of them. What is added is the list of methods that refuse. The two blocks
that ask it of a subject read as UTF-8 keep both answers and branch on
`__ENCODING__`, since a build without `MRB_UTF8_STRING` reads no encoding for
the bytes to break. One turned on what mruby knows about the string and now
asks that the refusal not turn on it. The other measures a lookbehind whose
bytes spell no character, and a UTF-8 build refuses such a subject before the
rewind runs, so only the build that reads no encoding still reaches the
measurement; the byte rewind it also asserts is reached in both.

The commit before this refuses a search whose subject holds a byte that spells
no character. It refuses one made with a String pattern as well, where CRuby
answers: a literal is searched for byte by byte and the subject is read as UTF-8
nowhere along the way.

```ruby
"あ\x80b".sub("b", "!")    # CRuby: "あ\x80!", before this: ArgumentError
"あ\x80b".scan("b")        # ArgumentError in both
```

`sub`, `sub!`, `gsub` and `gsub!` quote a String pattern into a `Regexp` before
they search, which hides what it was. Take note of it before the quoting and
carry the note down to the search: `Regexp.__search`, `__byte_search`,
`__sub_str` and `__gsub_str` each take a `checked` argument saying the caller
has settled the encoding question and the search must not ask it again.

`sub!` and `gsub!` search once themselves and then call `sub` and `gsub`, which
search again. The resolved pattern used to go down to that second call so that a
String was not quoted twice; a literal goes down as the String it was instead,
since that is what tells `sub` to leave the subject unread. Quoting it a second
time is the price of saying so.

`scan` is not exempt: CRuby refuses a literal there, so it keeps the check.
`index`, `partition`, `start_with?`, `slice!` and `[]` search a String pattern
in core without reaching a Regexp at all, so they already answer what CRuby
answers. So does `split`, which is where the two part company:
`"あ\x80b".split("b")` answers here and raises in CRuby. That divergence
predates both commits and is left where it was.

The tests are what CRuby answers for the six calls this exempts, the position
`sub` leaves in `$~`, and `scan` refusing a literal.