fix: settle what a case boundary is, and how a branch is named

[OmarAlJarrah]

Summary

Two naming decisions the compiler was making inconsistently, and the mechanism
that found one of them.

A canonical name drifted on a second pass. CanonicalWords("Aℤ") was "aℤ",
and CanonicalWords("aℤ") was "a_ℤ". wordBoundary asked unicode.IsUpper
while irverify.isCased asks whether lowercasing changes the value, and the two
disagree about a rune that is uppercase with no lowercase form of its own —
double-struck ℤ, GREEK UPSILON WITH HOOK ϒ, the Roman numerals. The grammar
split on such a rune, lowercasing left it unchanged, so it still looked like a
boundary and the next pass split it again. The consequence is worse than drift:
segmentation came to depend on the casing of the source spelling rather than on
its words, so COUNTℤ was one word and countℤ two, for names an emitter is
meant to treat alike.

The two boundary rules turn out to ask different questions, and settling that is
the fix. A camel-case boundary is a case transition, so it asks whether
lowercasing changes the rune — the same test the verifier applies, so producer
and checker now agree by construction. An acronym tail is the last of a run of
capitals, which is about the letter's form: ℤServer is ℤ_server whether or
not lowercasing would touch ℤ, and DžBc is dž_bc because a titlecase letter
belongs to a run too and IsUpper reports false for it.

An inline union branch was named by whichever lowering arrived first. A
oneOf/anyOf branch whose pointer an outside $ref also names took variant_0
from the composition or 0 from the pointer walk, depending on declaration
order — two different documents from the same components, silently. The $ref
half of this already agreed, because a $ref branch has a target both paths read
a name from; an inline branch has only its position. The composition's spelling
wins, both paths now go through one derivation, and 0 is not a name an emitter
can build an identifier from.

The grammar had no validation beyond a table of examples. canonicalCases
pins the answers, which is the right shape for a specification decision, but a
table only covers the rows someone wrote — and the defect above sat in a spelling
no row contained. A fuzz target now asserts what must hold for any input: the
grammar is a fixed point, its output is the word sequence Naming.Canonical
promises, and the word runes of that output are the lowercased word runes of the
input in order.

Test plan

• gofmt, go vet, golangci-lint, go build, and scripts/check-coverage.sh
  at exactly 100% of 3963 statements.
• Nine planted mutations, nine caught: both halves of the case definition, the
  grammar dropping case, dropping single-rune words, or mishandling one script,
  the branch hint reverting on either path, and the pointer parse widening or
  narrowing. The sweep earned its place — it found the acronym-tail change
  unverified, which is what surfaced that the two rules ask different questions.
• The properties are shown to catch what the table cannot: against the table as it
  stood before this branch, reinstating the case defect leaves it green and the
  target red. A grammar mishandling a single script does the same, and is a class
  a list of Latin examples cannot reach.
• The corpus carries the branch-collision shape for the first time. The two-order
  oracle detects this class already and no committed spec put it in reach. The
  case declares the reference before the union deliberately, since interning
  through the reference is the path that was wrong — otherwise a single-order
  golden cannot see the fix at all, which it could not until the two were swapped.
• No golden moved for the grammar change: no corpus name carries such a rune. The
  decision is pinned by nine conformance rows instead, and ir-design.md §3.2 now
  says which definition the contract means for each rule.

Notes

CLAUDE.md gains two rules, both paid for by the previous two branches: check the
tracker before settling a decision on a line a new guard forced you onto (#185
settled one that #184 had already framed, and needed #188 to correct), and treat a
fixture's own declaration order as part of the test.

Applying the first of those to this branch turned up two stale claims, corrected
here rather than left: #73's proposal for the naming grammar was ir and the docs
recorded the opposite, and #42's reproduction no longer holds. Both are commented
on their issues; #73 stays open for the half it still asks for.

Closes #181
Closes #186
Closes #187