tools: give the generated Unicode headers an include guard - #7192

The tables were gathered by asking the host CRuby to case every codepoint,
which put whichever Unicode version that Ruby happens to carry into
`unicase.h` and `re_cased.h`, left both headers reproducible only on a
machine carrying the same one, and let a regeneration run on two hosts leave
core and the regexp gem holding different Unicodes.

`tools/unicode/case_data.rb` reads `UnicodeData.txt`, `SpecialCasing.txt` and
`CaseFolding.txt` and hands out the mappings, and both generators take theirs
from it, so how a field is read is stated once. They read them out of a
directory named on the command line, defaulting to the one beside
`case_data.rb`, which is named after the version.

Which version is asked for is `VERSION` there rather than whatever the
directory happens to hold, and `CHECKSUMS` beside it says which bytes that
version is: a file whose digest is not the recorded one is refused rather than
generated from.

Reading the version off a first line would answer for two of the three files.
`UnicodeData.txt` carries no such line, and it is the file most of a table is
read out of, so a directory holding it from another release would generate the
simple mappings of that release, and the swap answers riding on its
decompositions, under a header naming this one. What a digest cannot say is
that the bump itself fetched what Unicode published; it pins the bytes that
were fetched, which is what every regeneration after it has to match.

The files are not in the repository. They are read when a table is
regenerated and at no other time, they weigh 2.3 MB against the 53 KB they
produce, and the license they carry would be a fourth exception in LEGAL for
something nothing compiles. CRuby does not track them either: `.gitignore`
there covers `/enc/unicode/data`.

The simple mappings come from the `UnicodeData.txt` fields, the full ones
from the unconditional `SpecialCasing.txt` entries, and folding from the C
and F entries of `CaseFolding.txt`. A conditional entry is one only a caller
that knows the language or the surrounding text can apply, which is why it is
skipped here as it is there, and why `"ΟΔΟΣ".downcase` stays `"οδοσ"`.

Two answers are in none of the files. The Georgian Mtavruli capitals title to
their lower case, which the database nowhere says and which CRuby spells as a
codepoint range in `enc/unicode.c`. And a title case character swaps to
neither of its cases: each piece of what it decomposes to swaps on its own,
so `U+01C5`, decomposing to D and ž, swaps to "dŽ".

For the refusals `re_cased.h` holds, the single counterpart a folding of
several characters may still leave keeps coming from the lower case mapping,
rather than from the S entries sitting beside the F ones. `U+1FD3`, `U+1FE3`
and `U+FB05` each have an S entry naming a codepoint they fold with, but
core's simple folding reads the folding difference over the lower case
mapping and reaches none of the three; a counterpart the engine cannot use is
not one to record. Both readings put the same codepoints in the table, so
this is about what the pass claims and not about what it writes.

`re_cased.h` also names its generator where it stands. The line read
`tools/gen_cased.rb`, which is where core's generator lives and not where
this one does, so anyone following it to regenerate the table reached the
wrong file.

### Verified

Both regenerated headers are identical to the committed ones apart from the
lines naming where they came from, so nothing compiled changes. Every mapping
was compared against what the host CRuby answers for the same codepoint over
`U+0080` to `U+10FFFF`, and they agree everywhere. The refusals come out of
them as 1,483 pairs and 76 skipped sources over 2,986 cased codepoints, and
reading the S entries instead leaves that cased set where it is.

A `UnicodeData.txt` with one line added to it, in a directory whose other two
files are untouched, is refused with both digests named. A check that read the
version off the first lines instead accepted that same directory, and wrote a
table of 185 lower case runs against 184 and 25 folding runs against 24 under
a header saying Unicode 17.0.0.

`MRUBY_CONFIG=ci/gcc-clang rake -m test`, KO 0, Crash 0 and Warning 0.