Share character/byte offset conversion between core and mruby-regexp - #7097

src/string.c and mruby-regexp each carry their own character/byte offset
conversion: the core statics chars2bytes / bytes2chars, and the gem's
re_char_to_byte / re_byte_to_char with duplicated #ifdef MRB_UTF8_STRING
branches. This PR promotes the core pair to internal API and rebuilds the
regexp pair on top of it.

Core

chars2bytes and bytes2chars become mrb_str_char_to_byte(mrb, str, off, nchars) and mrb_str_byte_to_char(mrb, str, bi), declared in internal.h
outside the MRB_UTF8_STRING guard, following the same pattern as
mrb_utf8_to_buf: the symbols exist on every build, and a non-UTF-8 build
gets identity functions in place of the former identity macros, so callers
need no conditional compilation. The conversion logic itself is unchanged,
and the off parameter stays because String#[] resolves a range by
converting the start first and then measuring the length from that byte
offset, avoiding a rescan of the prefix. Call sites inside string.c are in
the same translation unit and still inline, so generated code there does not
change.

mruby-regexp

re_byte_to_char and re_char_to_byte keep only the policy the gem owns
(negative position normalization for Regexp#match, -1 for out-of-range
positions, unmatched capture offsets passing through negative) and delegate
the walking to the shared functions. Both private loops and their
#ifdef MRB_UTF8_STRING / #else halves disappear.

Behavior fix on malformed UTF-8

The private regexp loops counted characters as "every byte that is not a
10xxxxxx continuation byte", while core indexing counts every invalid byte as
one character via mrb_utf8len. The two disagree on strings with stray
continuation bytes, so the same match could answer differently depending on
whether the single-byte flag had been computed yet:

s = "a\x80b"
/b/.match(s).begin(0)  # => 1, but s[1] is "\x80"
s.length               # => 3, marks the string single-byte
/b/.match(s).begin(0)  # => 2

With the shared conversion both matches report 2, the position where s[2]
is "b", agreeing with String#length and String#[]. A negative pos
argument counts back from the end with the same rules, so /a/.match(s, -3)
now finds "a" where it used to see a two character string and answer nil.
Well-formed UTF-8 is unaffected. As a safety net, an engine offset that lands
inside a multibyte character, reachable only on malformed input, is backed up
to the start of the containing character. A regression test pins the
positions down before and after the length is computed, and was confirmed to
fail against the previous implementation.

Testing

• rake test with build_config/host-debug.rb (full-core, so mruby-encoding
  defines MRB_UTF8_STRING): mrbtest 2229 OK / 0 KO, bintest 116 OK.
• rake test with the default config (byte strings, identity conversion):
  mrbtest 2030 OK / 0 KO, bintest 105 OK.
• The new assertions in mruby-regexp/test/regexp_utf8.rb fail against the
  previous conversion (begin, end, String#[] agreement, and negative
  pos all answer differently there) and pass with this change on both
  builds.

Summary by CodeRabbit

• Bug Fixes
  • Improved character and byte position handling for UTF-8 strings, including malformed input and out-of-range offsets.
  • Corrected regular-expression match positions for positive and negative offsets.
  • Ensured matching at the end of a string returns the expected empty match.
  • Improved consistency across string indexing, slicing, replacement, reversing, and splitting operations.
• Tests
  • Added coverage for malformed UTF-8 position handling and end-of-string matches.