string.c: convert case the way the string is read, not the way bytes are - #7182

`String#swapcase` walked the bytes and swapped 'A' to 'Z' against 'a' to 'z',
so a build that reads a string as characters answered `"Äö"` for the swap of
`"Äö"`. The three methods in core stopped doing that; this is the fourth.

Reach the walk in core from here rather than carrying a second one:
`mrb_str_case_convert_unicode()` takes what to do as a mode, so the tables are
asked about in one place and swapping is one more mode of the four.

```ruby
"Äö".swapcase   #=> "äÖ"
"ßA".swapcase   #=> "SSa"
```

Swapping is stored as its difference from a rule, the way title case is
stored as its difference from upper case: a character with a lower case is an
upper case one and swaps down, one without swaps up. The rule is right about
every character but 31, all of them title case ones, which CRuby swaps to
something neither of their cases spells. `U+01C5` upper cases to `U+01C4` and
lower cases to `U+01C6`, and swaps to "dŽ". Those 31 are the whole of the
`swap` table.

The ASCII loop this method had stays where it is and answers for a string of
nothing but ASCII as it always has, so a byte indexed build is unchanged, byte
for byte.

### Size

A character indexed build grows by 648 bytes: 155 for the 31 entries, 141 for
the pool they spell themselves in, 24 for the table descriptor, and the rest
for the mode reaching the walk and the rule it falls back on.

### Verified

`MRUBY_CONFIG=ci/gcc-clang rake -m test`, all four builds and the bintests,
KO 0, Crash 0 and Warning 0. Every answer asserted was read off CRuby 4.0.6
first.

`casecmp?` was `casecmp(other) == 0`, and `casecmp` orders strings by ASCII
case, so `"ä".casecmp?("Ä")` was false. CRuby answers the two apart: `casecmp`
is ASCII there too and says 1, while `casecmp?` folds and says true.

Folding is a third thing beside upper and lower case, not a spelling of
either: it maps "ß" to "ss" so that the two compare equal, which is nobody's
lower case. Carry it in `unicase.h` beside the others and reach it as a mode
of the same walk.

```ruby
"ä".casecmp("Ä")    #=> 1
"ä".casecmp?("Ä")   #=> true
"ß".casecmp?("ss")  #=> true
"fi".casecmp?("fi")  #=> true
```

Both sides are folded and compared whole rather than character against
character, since a folding can spell one character as several and the two
strings then hold different numbers of them. Only one of them has to hold a
character above ASCII for both to be folded: `"ß".casecmp?("SS")` is true, and
the walk over characters hands a string of nothing but ASCII back untouched,
so that side is folded here instead.

Folding is stored as its difference from the lowercase mapping, the way title
case is stored as its difference from upper case. The two answer alike for all
but 108 sources, so the difference is 24 runs where a table of its own would
take 198, and the 114 sources the lowercase mapping has that folding leaves
alone are its runs of delta 0.

A comparison with nothing above ASCII on either side leaves the tables nothing
to say and keeps the byte walk it had, so a byte indexed build is unchanged,
byte for byte, and so is `casecmp` in every build.

A character indexed build grows by 1,264 bytes: 144 for the runs, 515 for the
103 multi character foldings, 320 more in the pool they spell themselves in,
24 for the table descriptor, and the rest for the mode and the folding of an
ASCII side.

`MRUBY_CONFIG=ci/gcc-clang rake -m test`, all four builds and the bintests,
KO 0, Crash 0 and Warning 0. Every answer asserted was read off CRuby 4.0.6
first, including `"İ".casecmp?("i")` being false: U+0130 folds to "i" plus
U+0307, which "i" alone does not match.

A case conversion asks each character what case it has. A run of bytes that
spells no character has none, and the walk was handing it back as it stood,
which reads as an answer: `"\xC3ABC".downcase` came back as `"\xC3abc"`, a
string whose first byte still spells nothing.

Raise `ArgumentError` there instead, which is what CRuby answers for the same
input, message and all:

```ruby
"\xC3ABC".downcase   # ArgumentError: input string invalid
```

The refusal covers the four conversions and `casecmp?`, since all five walk
the characters. `casecmp` orders bytes without asking what they spell and goes
on doing that, which is CRuby's split too. A string read as bytes is not
affected either: it spells no characters at all, so it takes the ASCII walk
and has nothing to refuse.

A refused conversion leaves the receiver as it was, the bang forms included:
the walk builds its answer beside the string and the string takes it only at
the end, so there is nothing half converted to hand back.

What the walk records afterwards gets simpler by the same stroke. Every byte
it read spelled a character and every mapping spells characters, so the result
is sound UTF-8 rather than "whatever the source was", and the coderange it
stores says so.

### Size

29 bytes on a character indexed build, the check being one comparison the walk
already had the value for. A byte indexed build is unchanged.

### Verified

`MRUBY_CONFIG=ci/gcc-clang rake -m test`, all four builds and the bintests,
KO 0, Crash 0 and Warning 0.

The define was documented as adding UTF-8 to the character oriented String
methods, which is where it stood when case conversion folded 'A' to 'Z' in
every build. It now decides that too, so the three places that name the define
say so.

`String#casecmp` gets a line of its own in the gem's README, since it is the
one case method the define does not reach: it orders strings by ASCII case
whatever the build, and `casecmp?` beside it is the one that folds.