unicase.c: keep one Unicode case table rather than two - #7183

`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.

`mruby-regexp` carries the simple case foldings for /i, and core now carries
the full ones for `String#casecmp?` and the four conversions. Those are the
same 1,483 sources: the full folding of a character either spells one
character, which is what /i wants, or spells several, which /i leaves alone. A
build with the option on was paying for both tables and could disagree with
itself about a folding if one were regenerated and the other were not.

Move the tables and the walks over them into `src/unicase.c`, which knows
about codepoints and nothing about strings or patterns. `string.c` asks it for
a mapping, `mruby-regexp` asks it for a folding, and `re_casefold.h` is gone.

Simple folding is the two run tables read in order, the folding difference
first and the lowercase mapping under it, which is what the difference is a
difference from. `U+1E9E` folds to "ss" fully and pairs with `U+00DF` simply,
and each reader finds its own answer without a second table.

`tools/gen_casefold.rb` no longer generates a folding, so it is
`tools/gen_cased.rb` now: what it writes is `re_cased.h`, the codepoints a
build without the option refuses under /i. It still reads the whole of the
folding data, since what has to be refused is defined by what the other build
folds.

The two directions /i needs over the table are compiled only where the option
asks for them, so a build reading characters without it carries the table its
String methods need and none of the code /i would. What answers is therefore
the option and `MRB_UTF8_STRING` together, which is what `RE_UNICODE_CASE`
spells, and `mrbgem.rake` picks the case test file off that pair rather than
off the option alone: the file that asserts /i folds and the file that asserts
/i refuses have to land on the same side as the code does.

### Size

A build with the option drops 1,511 bytes of text: the 2,460 byte table that
was in the gem is gone, and the walks that were in it move to core, where they
lose an ASCII branch they now share.

A build without it moves by 20 bytes or fewer, and a byte indexed build by
none: what `size` reports there as 80 bytes is `.note.gnu.property` on an
otherwise empty object file, and the linked binary is 24 bytes smaller than
before this branch, which is what the first commit of it accounts for.

### Verified

`MRUBY_CONFIG=ci/gcc-clang rake -m test` from a clean build directory, all
four builds and the bintests, KO 0, Crash 0 and Warning 0. The clean build
matters here: a stale object file kept the deleted header's table and its
tests passed on the old code.

Simple folding was checked against the table it replaces over every codepoint
from 0x80 to 0x10FFFF, all 1,483 sources of the old table included: the two
agree everywhere.

`MRB_REGEXP_UNICODE_CASE` named an option that carried a table of its own
inside the gem. The table is core's now, and what the option turns on is the
two walks over it that /i needs, which sit in core beside the table. A define
named for one gem is the wrong name for something core compiles.

Rename it `MRB_UNICODE_CASE` and give it an entry in mrbconf.md, where the
gem-local name had none. Nothing else moves: the same builds fold the same
characters, and `mruby-regexp` goes on being the only caller. The refusal a
build without the option raises names the new spelling, which is 16 bytes
shorter, and that is the whole of the size difference.