Check the Unicode range in mrb_utf8_to_buf instead of in its four callers - #7129

The duplication

mrb_utf8_to_buf() took a uint32_t, so a value outside the Unicode range
wraps into a codepoint under the cast: (uint32_t)(0x100000000 + 0x41) is
0x41, and the encoder would spell A. Every caller therefore had to test
the range on the mrb_int before the call, and all four spelled the same
bound out:

Because all four rejected anything above U+10FFFF first, the return 0 the
encoder already carried for a value it cannot spell was unreachable from
every one of them. Two of the four also carried a copy of the same comment
explaining the cast.

The change

Take an mrb_int. The cast disappears, and with it the reason the bound
could not live in one place. Each caller keeps only the part that genuinely
differs between them, which is the exception:

sprintf("%c", 0x110000)   # ArgumentError: invalid character
[0x110000].pack("U")      # RangeError
0x110000.chr("UTF-8")     # RangeError

CRuby 4.0.6 raises those same three, so this split is not one the encoder can
absorb.

What stays where, and why

Integer#chr keeps its surrogate test. A surrogate is a value the encoder
does spell, and CRuby spells it too:

sprintf("%c", 0xD800).bytes   #=> [237, 160, 128]
[0xD800].pack("U").bytes      #=> [237, 160, 128]
0xD800.chr("UTF-8")           # RangeError: invalid codepoint 0xD800 in UTF-8

So refusing a surrogate is a rule of Integer#chr rather than a rule of
UTF-8 encoding. It also means what mrb_utf8_to_buf() writes is deliberately
wider than what mrb_utf8len() reads back under RFC 3629, and

sprintf("%c", 0xD800).valid_encoding?   #=> false

in CRuby as well as in mruby. The encoder's comment now states that where the
encoder is defined, instead of leaving it to be inferred from which callers
happen to carry a surrogate test.

mruby-regexp keeps check_unicode_cp(). It reports at the point the
pattern is read rather than at the point bytes are emitted, and the message
carries the pattern:

Regexp.new("\\u{D800}")   # RegexpError: invalid Unicode range: /\u{D800}/

Its codepoint also comes from a hex scan capped at six digits, so it can
never reach the encoder unchecked.

mruby-pack gained its own version of this check in #7114, for the same
reason the other three carried one. With the cast gone, that reason is gone
with it.

Tests

The first commit pins what the encoder spells for a surrogate, before
anything moves. The upper bound, negative values and the truncation case
already had tests; the writing side had none. Adding a surrogate rejection to
mrb_utf8_to_buf() fails exactly the two new assertions and nothing else.

No behavior change. Three builds, one with MRB_UTF8_STRING, one without,
and one with MRB_UTF8_STRING and MRB_INT32, agree with the previous code
on -1, -0x10FFFF, 0, 0x7F, 0x80, 0x7FF, 0x800, 0xD7FF,
0xD800, 0xDFFF, 0xE000, 0xFFFF, 0x10000, 0x10FFFF, 0x110000,
0x7FFFFFFF and 32-bit truncation candidates, across sprintf("%c"),
pack("U"), Integer#chr("UTF-8") and String#<<. rake test is green on
all three, and each commit was checked on its own.

Summary by CodeRabbit

• Bug Fixes

  • Improved UTF-8 handling for integer-to-character conversions across packing, formatting, regular expressions, and string utilities.
  • Invalid negative, oversized, and out-of-range code points are now rejected consistently.
  • UTF-16 surrogate values now produce consistent UTF-8 output and round-trip behavior where supported.
  • %c formatting reports a clear “invalid character” error for unsupported values.

• Tests

  • Expanded coverage for surrogate code points, adjacent Unicode characters, exact UTF-8 bytes, and values exceeding 32-bit ranges.