mruby-regexp: close the pattern dispatch in the String overrides - #7079

The byte-space loops in `gsub` (block form), `split` and `byteindex`
drove their search through `pattern.__byte_match(self, pos)`, an
ordinary method call on the pattern, so a method rewritten on a Regexp
instance replaced the search under the loop:

```ruby
r = /l+/
def r.__byte_match(*args); "PWNED"; end

"hello".gsub(r) { |m| m.upcase }
# CRuby: "heLLo", mruby: NoMethodError for `__byte_begin` on String
```

`Regexp.__byte_search` is the same thin wrapper over `exec_match()`
with the pattern as an argument, so the search stops being redefinable
while both loops stay in Ruby, where the block call and the field list
belong. As with `Regexp.__search`, there is no position normalization,
because the callers already work in byte space, and no operand
conversion, because they always pass a String.

The instance form had no caller left outside these three sites, so it
is removed rather than kept alongside: `__byte_match` was an internal
of this gem, and its replacement takes over its method table slot
rather than adding one.

`__sub_str`, `__gsub_str` and `__scan` are the whole-operation entry
points of `sub`, `gsub` and `scan` with a replacement string: each runs
an entire operation in C and hands back its result. They took the
pattern from `self`, so the mrblib callers reached them through an
ordinary method call on the pattern, and a method rewritten on a Regexp
instance replaced the whole operation. This was the quietest part of
the surface, because the caller got the redefinition's return value
verbatim and nothing raised on the way:

```ruby
r = /l+/
def r.__sub_str(*args); "PWNED"; end

"hello".sub(r, "X")       # CRuby: "heXo", mruby: "PWNED"
"hello".dup.sub!(r, "X")  # worse: the receiver became "PWNED" too
```

CRuby closes all of these: its `sub`, `gsub` and `scan` reach the
pattern through `rb_pat_search()`, which searches a real Regexp without
asking it anything.

Each core becomes a class method taking the pattern as its first
argument, the boundary `Regexp.__search` already draws for the plain
searches. The instance forms had no caller left outside the gem, so the
class forms take over their method table slots rather than adding new
ones. The bodies themselves are unchanged: they already ran without
calling back into Ruby, which is why they are in C at all.

`sub!` and `gsub!` reach the same two cores by calling `sub` and `gsub`
with a pattern they already resolved, so they are closed by the same
change, receiver included.

These two are the overrides whose CRuby counterparts do not dispatch to
the pattern at all: `rb_str_match_m_p()` resolves the argument and
searches it, and `rb_str_match()` sends `=~` to the argument only when
it is neither a String nor a Regexp. The overrides here asked the
pattern on every path, so for a real Regexp they answered whatever a
rewritten method answered, and nothing raised on the way:

```ruby
r = /l+/
def r.match?(*args); "PWNED"; end
def r.=~(*args); 99; end

"hello".match?(r)  # CRuby: true, mruby: "PWNED"
"hello" =~ r       # CRuby: 2,    mruby: 99
```

`String#match?` now hands the pattern to `Regexp.__search_p`, which is
`Regexp#match?` with the pattern as an argument: the same search with a
NULL capture buffer, so it allocates no MatchData and leaves the match
globals alone. `String#=~` searches a real Regexp through the existing
`Regexp.__search` and reads `begin(0)` from the MatchData, so no second
entry point is needed; the globals it publishes and the character
offset it answers are the ones `Regexp#=~` produced before.

The forward for everything that is not a Regexp stays, because CRuby
forwards there too: `"hello" =~ obj` still reaches the argument's own
`=~`. Only the branch in front of it changed, from every argument to
the non-Regexp ones.

The comment at the top of string_regexp.rb described a file where every
override reached its pattern through redefinable methods, and argued
that the gem accepts that surface rather than closing it. The previous
commits closed it, so the description no longer holds; what is left to
say is smaller.

The type-check paragraph survives unchanged, because nothing about the
argument checks moved. The surface paragraphs give way to what the file
does now: the searches go through class methods that take the pattern
as an argument, the MatchData comes from C, and the reachable remainder
is a class-wide redefinition of a MatchData method, which is the same
category as redefining `String#sub` itself.

The CRuby comparison stays, inverted: `String#match` dispatching
`match` on purpose (`rb_str_match_m()`) and `=~` forwarding a
non-Regexp argument (`rb_str_match()`) are now the two deliberate
exceptions rather than the two ends of an open range.