mruby-regexp: accept a Symbol on the Regexp side of a match - #6995

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:

/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:

%i[to_s to_i size].grep(/^to_/)   # CRuby: [:to_s, :to_i], mruby: []

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.

Relation to #6993

Updated the README and comments following the merge of #6993.

sym[/re/] stays a third gap, waiting on the regexp form of String#[]. None
of the three closes the others.

Testing

Seven assert blocks in mrbgems/mruby-regexp/test/regexp.rb, one per entry
point plus the cases the conversion is responsible for:

• #match: MatchData, captures, #string, #pre_match, $~, named captures,
  the block form, and nil on no match
• #match with pos, so the offset argument is reached through a Symbol
• a multibyte symbol name, which never fits the inline representation and so
  always takes the shared-buffer path into the offset conversion
• mutating MatchData#string leaves the symbol table intact
• #match? with and without pos, both polarities
• #=~, including $~ cleared on no match
• #=== via Enumerable#grep and via case/when
• the operand types that are still refused, and that #=== answers false for
  them rather than raising

Every expected value was taken from CRuby 4.0.6. A 23-case comparison against
it leaves four differences, all of them pre-existing and outside this change:
MatchData#inspect, the wording of mruby's TypeError messages, MatchData#string
not being frozen, and String#match with a Symbol pattern (#6994).

rake test is green in both string modes:

No existing test changed.

Summary by CodeRabbit

• New Features

  • Regular expression matching now accepts symbols and matches against their names across supported matching operators.
  • Symbol operands support offsets, captures, blocks, multibyte characters, and case statements.
  • Matching preserves isolation between symbol and string data.

• Bug Fixes

  • Preserved appropriate handling for unsupported operand types, including errors or false results depending on the operator.

• Documentation

  • Updated regular expression documentation to describe symbol matching support.