Share the character count between core and mruby-string-ext - #7104

`String#slice!(str)` searches with `mrb_str_index()`, which answers a byte
offset, and turned that into a character index by counting the characters
of `mrb_str_substr(mrb, self, 0, pos)`. `mrb_str_substr()` reads its
arguments as character positions, so the byte offset arrived there as a
character count and the substring it cut is longer than the part before the
match. The index that comes out is too large:

```ruby
"あいう".slice!("い")  #=> ""  (expected "い")
```

`"い"` starts at byte 3, `mrb_str_substr()` takes the 3 as three characters
and hands back the whole receiver, and the match is reported at character
3 rather than 1. The length is then clamped against the receiver, which
leaves nothing to cut.

`mrb_str_byte_to_char()` is the conversion this wants, and it also settles
what to do when the offset is not the start of a character: the search runs
over bytes and can land inside one, which it reports as -1. CRuby finds no
match in that position, so answer nil for it.

`utf8_strlen()` counts the characters of a string the way the string
itself is indexed: a binary or single-byte string has one character per
byte, everything else is measured as UTF-8. It belongs with
`mrb_str_char_to_byte()` and `mrb_str_byte_to_char()`, which answer
positions under that same rule, but unlike them it was static and
reachable only through the `RSTRING_CHAR_LEN` macro. mruby-string-ext
carries its own copy of it for want of a shared one.

Give the count the shape the two conversions already have:
`mrb_str_char_len(mrb, str)`, declared in `internal.h` outside the
`MRB_UTF8_STRING` guard, with a definition on the other side of the
guard that returns the byte length. Both `RSTRING_CHAR_LEN` definitions
go away and the six uses call the function.

The `mrb` argument goes unused here as it does in the two conversions.
It is in the signature so the three read alike where they are called.

`str_char_count()` is `mrb_str_char_len()` written a second time: a
binary or single-byte string counts one character per byte, anything
else goes through `mrb_utf8_strlen()`. Call the core helper and drop
the copy.

The helper is declared outside the `MRB_UTF8_STRING` guard and returns
the byte length on a build without UTF-8 support, so `String#slice!`
loses the guarded branch it chose its length with. `ljust`, `rjust` and
`center` were already calling the copy from outside any guard.

The core helper also keeps what it learns: a string whose byte length
and character count agree is marked single-byte, so the next question
about it is answered without walking the bytes again. The copy threw
that away.