mruby-regexp: pass the block through String#match - #6991

CRuby defines `match`, `match?` and `=~` on Symbol so that a symbol can be
matched against a regexp without spelling out the `to_s`; mruby-regexp
provided none of them, so any regexp use on a symbol raised NoMethodError.

```ruby
:abc.match?(/b/)   # CRuby: true,  mruby: NoMethodError
:abc =~ /b/        # CRuby: 1,     mruby: NoMethodError
```

CRuby implements all three as the String method applied to the symbol's name
(`rb_sym2str` then `rb_str_match_m` / `rb_str_match`), so they delegate to
`to_s` rather than repeat the pattern handling. That inherits the String
pattern compilation, the `pos` argument, the block form, and the `TypeError`
for a String argument to `=~`. `$~` and `$1`-`$9` are set by the engine
itself, so delegating does not lose them.

`Symbol#match` needs the block to survive the delegation, which #6991 made
`String#match` do.

Delegating also inherits one difference from CRuby that is worth naming: for
an argument that is neither a Regexp nor a String, `String#=~` dispatches
`re =~ self`, so `:a =~ nil` raises NoMethodError where CRuby returns nil.
Fixing that belongs to `String#=~`, not to the Symbol wrapper.

This covers the symbol-on-the-left direction only. The Regexp side still
takes strings only, and rejects symbols in every entry point rather than just
in `#===`:

```ruby
/l/ =~ :hello        # TypeError (CRuby: 2)
/l/.match(:hello)    # TypeError (CRuby: MatchData)
/l/.match?(:hello)   # TypeError (CRuby: true)
/l/ === :hello       # false     (CRuby: true)
[:to_s, :abc].grep(/^to_/)  # [] -- Enumerable#grep goes through Regexp#===
```

`sym[/re/]` is a third gap: `mruby-symbol-ext` already delegates `Symbol#[]`
to `String#slice`, but this gem does not implement the regexp form of
`String#[]` / `#slice`, so `"hello"[/l+/]` does not work either. Both are
fixes on the String and Regexp side, so they are left alone here; the README
Limitations section and the comment in symbol_regexp.rb now spell them out.