mruby-regexp: add Symbol#match, #match? and #=~ - #6993

`String#match` and `#match?` converted a `String` argument to a `Regexp`
and handed `self` straight to anything else, so a pattern of the wrong
type reached a method call it does not respond to.  The failure named the
argument as the receiver, which says nothing about the pattern being
wrong.

```ruby
"abc".match(:b)   # CRuby: TypeError, mruby: NoMethodError for :b
"abc".match(nil)  # CRuby: TypeError, mruby: NoMethodError for nil
```

Resolve the pattern in one helper so both methods reject the same set,
and follow CRuby in naming `nil`, `true` and `false` by value and
everything else by class.  The check runs before `pos` is inspected,
matching CRuby's order.  The helper is private, so the gem does not grow
`String`'s public API with a method only `match` and `match?` call.

```ruby
"abc".match(:b)       # TypeError: wrong argument type Symbol (expected Regexp)
"abc".match(nil, 99)  # TypeError on the pattern, not an error about pos
```

CRuby also accepts an object that defines `to_str`, converting it through
`rb_check_string_type` before the type check.  mruby has no implicit
`String` conversion in core, so `"a" + obj` and `"abc".index(obj)`
already raise `TypeError` for such an object; honouring `to_str` in
`match` alone would make the gem more permissive than the core it sits
on.  Rejecting `to_str` objects therefore stays an intentional
difference from CRuby.

`String#=~` deliberately keeps its current behaviour.  CRuby's
`rb_str_match` special-cases `String` only and dispatches everything else
as `other =~ self`.

```ruby
"abc" =~ 1    # CRuby: NoMethodError, mruby: NoMethodError
"abc" =~ nil  # CRuby: nil,           mruby: NoMethodError
```

A blanket type check would turn both into `TypeError`, losing the case
mruby already matches and freezing the other in a state it can never grow
out of.  `Object#=~` was removed in Ruby 3.2, so `nil` is the only
receiver left to dispatch to, and the NoMethodError becomes CRuby's `nil`
the moment core gains `NilClass#=~`.  That is a core fix rather than one
for this gem.

This becomes more urgent once `Symbol#match` exists (#6993).
`Symbol#match` and `#match?` delegate to `to_s`, so without the check the
receiver and the argument swap places and the call quietly succeeds.

```ruby
"abc".match(:b)  # without the check: :b.to_s.match("abc") -> nil
                 # with the check:    TypeError
```

CRuby matches a Symbol against its name wherever a Regexp is given a subject,
through `reg_operand()`. mruby-regexp took strings only, so all four entry
points refused a symbol:

```ruby
/a/ =~ :ab       # CRuby: 0,         mruby: TypeError
/a/.match(:ab)   # CRuby: MatchData, mruby: TypeError
/a/.match?(:ab)  # CRuby: true,      mruby: TypeError
/a/ === :ab      # CRuby: true,      mruby: false
```

`#===` is the one that matters most. It answers false instead of raising, so a
`case` over symbols quietly falls through to `else` and `Enumerable#grep`
returns an empty array, with nothing to show that the pattern was never given
a chance to run.

Convert the operand with `mrb_sym_str()` in one helper and call it from
`regexp_match()`, `regexp_match_p()` and `regexp_match_op()` in place of
`mrb_ensure_string_type()`. `regexp_case_match()` uses the same helper behind
a type test, because `#===` has to keep answering false for a type it cannot
match rather than start raising. `__byte_match` is left alone: it is internal,
is only reached from mrblib with `self` as the subject, and its argument spec
already pins the type.

For a symbol too long for the inline representation, `mrb_sym_str()` returns
an `mrb_str_new_static()` string sharing the symbol table's buffer. Mutating
the `MatchData#string` that comes out of one is safe, because `str_modify()`
copies an `RSTR_NOFREE` buffer before writing, but a test pins that.

This is the Regexp-side half of the symbol support mruby#6993 adds on the Symbol
side, and neither closes the other. mruby#6993 delegates `Symbol#match` and friends
through `to_s`, so it never reaches the C code changed here; the two are
independent and can land in either order. If mruby#6993 lands first, its
"Symbols only on the left of a match" entry in the gem README becomes stale
and should be dropped as part of the merge. `sym[/re/]` stays a third gap,
waiting on the regexp form of `String#[]`.