mruby-regexp: add the regexp form of String#[]= and String#slice! - #7063

The read side landed as `String#[]` and `String#slice`, but the write
side still funnels a Regexp through an Integer conversion and fails with
a type error that names Integer:

```ruby
s = +"hello"
s[/l+/] = "X"            # CRuby: "heXo", mruby: TypeError
s[/(?<x>l+)/, :x] = "Y"  # CRuby: "heYo", mruby: TypeError
s.slice!(/l+/)           # CRuby: "ll",   mruby: TypeError
s.slice!(/(l)(o)/, 1)    # CRuby: "l",    mruby: TypeError
```

`mrb_str_aset()` shares `str_convert_range()` with `mrb_str_aref()`, so
it has the same three accepted index types and the same fallback to
`mrb_ensure_int_type()`.  `mrb_str_slice_bang()` does its own conversion
and reaches `mrb_as_int()` for anything that is neither a String nor a
Range.  It is easy to miss when grepping: it is registered as
`MRB_SYM_B(slice)`, so the literal `slice!` appears nowhere in the tree
outside its own tests.

Override both in `mrblib/string_regexp.rb`, in the shape `[]` uses there:
capture the C-defined method under a `__` name, hand every argument list
that does not start with a Regexp straight back to it, and read the
argument's type with `Regexp ===` rather than `is_a?`.  No new C is
needed.  `MatchData#begin` and `#end` resolve a group name and report
character offsets, which is the space the two-integer form of `[]=` works
in, so a named group's span is reachable from Ruby and a multibyte
subject needs no further conversion.

The two halves disagree in three places, and CRuby is followed in each:

- An unusable capture argument.  `[]=` raises `IndexError` both for an
  index that reaches no group and for a group that exists but did not
  take part in the match, where `slice!` answers nil for the first and
  `""` for the second.  The `""` falls out of `rb_str_slice_bang()`
  building its result from the group's `-1` offset rather than out of a
  decision, but it is what CRuby answers.  A negative index is
  normalized the same way on both sides, which puts group 0 out of its
  reach; `MatchData#begin` rejects every negative index with a wording
  of its own, so neither the normalization nor the range check can be
  left to it.
- A name that resolves to no group is the one case that raises for both,
  and `MatchData#begin` already raises it with CRuby's message.  A name
  that resolves to a group which did not take part in the match is
  reported by CRuby with the group's number, which is not reachable from
  Ruby, so the message repeats the name as it was given.
- The frozen check.  CRuby searches before it modifies for `[]=`, so a
  frozen receiver raises only once the match has been published, and a
  pattern that does not match raises `IndexError` rather than
  `FrozenError`; letting the mutation be what raises reproduces both.
  For `slice!` CRuby checks first, as `mrb_str_slice_bang()` already
  does, so the override asks `frozen?` before it searches and leaves
  `$~` alone.

A Regexp goes through `Regexp#match` rather than `#match?`, because the
match globals have to be published here, including the clearing a failed
match does before `[]=` raises and before `slice!` returns nil.  The
MatchData left behind describes the subject as it was before the
replacement, since `create_matchdata()` snapshots it.

The replacement reaches the core method's type check unconverted, the way
the `sub` override refuses to invent an implicit conversion.  Its message
reads `Symbol cannot be converted to String` where CRuby says `no
implicit conversion of Symbol into String`; that wording is the core's
throughout and is not this change's to fix.

Unlike the read side, this override is not free.  `vm_op_getidx()`
answers `str[Integer]`, `str[String]` and `str[Range]` from C, which is
what keeps `[]` off the common paths, but `vm_op_setidx()` optimizes
Array and Hash only and sends `[]=` for everything else, so every
`str[...] = repl` pays a Ruby frame on its way to `__aset` once this gem
is in the build.  The delegation guard is a single `Regexp ===` before
any other work.