mruby-string-ext: String#slice! cuts a multibyte string by characters - #7103

String#slice! in mruby-string-ext converts between character indexes and byte
offsets on its own, and both directions are wrong on a multibyte string. The
result is a broken return value and a broken receiver:

s = "あいうえお"
s.slice!(3, 2)  #=> "\xE3\x81"     (CRuby: "えお")
s               #=> "あいう\x88お"  (CRuby: "あいう")

s = "あいう"
s.slice!("い")   #=> ""            (CRuby: "い")
s               #=> "あいう"        (CRuby: "あう")

Two independent defects, one commit each.

Character index to byte offset

str_char_to_byte_offset() and str_chars_to_byte_len() hand mrb_utf8len()
an end of p + byte_len - byte_offset. That is the end of the string only
while byte_offset is zero: every character consumed moves it one character
closer to the start. A character reaching past the moved end is measured as
truncated, which mrb_utf8len() reports as a single byte, so the conversion
answers an offset that lands inside a character.

mrb_str_char_to_byte() does this in core and is what String#[] goes
through, which is why "あいうえお"[3, 2] answers "えお" where slice! does
not. Both static helpers are deleted.

Byte offset to character index

mrb_str_index() answers a byte offset, which was passed to
mrb_str_substr() as a character count. mrb_str_byte_to_char() is the
conversion this wants. It also settles the case the byte search can produce
and the old code could not express: an offset inside a character, which it
reports as -1. CRuby finds no match in that position, so slice! answers nil
for it.

Both core conversions are declared outside the MRB_UTF8_STRING guard and are
the identity on a build without UTF-8 support, so the guarded branches go away
with the helpers.

Tests

Two assertions in mrbgems/mruby-string-ext/test/string.rb, guarded by the
UTF8STRING flag the file already uses. Each fails before its own commit and
passes after it. The existing String#slice! assertions are ASCII only, where
a character is a byte and neither defect shows.

Verified

• rake test on a full-core build (MRB_UTF8_STRING through mruby-encoding):
  2237 tests, all green
• rake test on the default gembox (no MRB_UTF8_STRING): 2053 tests, all
  green
• prek run --all-files passes, except that markdownlint could not install
  locally (npm engine mismatch); no Markdown is touched here

Summary by CodeRabbit

• Bug Fixes
  • Improved String#slice! handling for UTF-8 and multibyte strings.
  • Character-based indexes, ranges, negative indexes, and byte lengths now produce consistent results.
  • Prevented slicing from starting within a UTF-8 character.
  • Improved slicing by multibyte string matches, including unmatched and invalid byte-position cases.