String#chars splits where String#length counts - #7106

`str_scrub_char_len()` asks whether the bytes at p start a valid UTF-8
character and, if they do, how many bytes it takes. `mrb_utf8len()`
answers that question in core, and answers it by the same rules: both
were brought to RFC 3629 in mruby#7093, one after the other.

What has to be bridged is how a refusal comes back. `mrb_utf8len()`
answers 1 for every sequence it turns down, and a real one-byte
character is a lead byte below 0x80, so a length of 1 on a byte at or
above 0x80 is the refusal.

The two were checked against each other over both leading bytes, nine
representative tail bytes and every available length from 1 to 4:
21,233,664 cases, no difference.

`utf8code()` judged the sequence itself before decoding it: the
continuation bytes, then the RFC 3629 rules for overlong encodings,
surrogates and code points above U+10FFFF, all written a second time.
`mrb_utf8len()` passes that same judgment, so ask it and decode what it
accepts.

`String#codepoints` stepped over each character by the raw
`mrb_utf8len_table`, which is the length a lead byte claims rather than
the length that was accepted. The two agree wherever `utf8code()`
returns, but the caller no longer has to know that: the byte length
comes back through `lenp`. The table is still read by `String#chars`,
so the declaration stays.

The two were checked against each other over the same 21,233,664 cases
as `str_scrub_char_len()`, with no difference in the code point, in
what is refused, or in the byte length.

`str_chars_ary()` measured each character itself, by the length its lead
byte claims with the continuation bytes checked. That accepts what
RFC 3629 forbids and core refuses: an overlong encoding, a UTF-16
surrogate, a code point above U+10FFFF. The same string was then cut
into fewer pieces than it was counted as having:

```ruby
"\xC0\x80".chars       #=> ["\xC0\x80"]  (CRuby: ["\xC0", "\x80"])
"\xC0\x80".length      #=> 2
"\xED\xA0\x80".chars   #=> ["\xED\xA0\x80"]
"\xED\xA0\x80".length  #=> 3
```

Walk with `mrb_utf8len()`, the measure the count is taken by, and the
two agree again. `mrb_str_char_len()` gives the array its capacity,
which is now the number of characters rather than a byte length halved,
and on the way there it settles the single-byte flag the walk reads.

The gem is left reading no UTF-8 table of its own, so the declaration
goes with the loop.

The table says how many bytes a lead byte claims. That is the first
question `mrb_utf8len()` asks and no answer on its own: it says nothing
about whether the bytes that follow make the character claimed, which
is the whole of what the function goes on to check.

mruby-string-ext was reading the table directly and cutting strings by
it, which is what the previous commit ended. Nothing outside this file
reads it now, so let the file keep it.