ir: canonical-naming grammar and primitive IDs are cross-compiler ABI living in one compiler

[OmarAlJarrah]

Problem

Two things every compiler must produce byte-identically are currently private code inside compilers/openapi:

1. The canonical-naming grammar. canonicalWords (schema.go:1112-1149) defines what Naming.Canonical looks like (invariant 4's neutral word sequence). irverify only checks lowercase-idempotence, not word-splitting — so a TypeSpec compiler with its own splitter (HTTPServer → httpserver vs http_server) passes every oracle while breaking cross-format dedup/correlation and emitter casing consistency.
2. Interned primitive IDs. t/prim/<kind> (ids.go:48) is referenced by golden files and will be emitted by every compiler — IR-level ABI defined nowhere in ir.

The RFC 6901 ptr/escape helpers and the diagf constructor are the same category of compiler-common machinery. Once a second compiler ships its own copies, the goldens of both lock in any divergence.

Proposed direction

Move canonicalWords into ir (e.g. ir.CanonicalWords) as the normative definition of Naming.Canonical — stdlib-only, no more "parsing" than NewDiagnostic's UTF-8 coercion — and tighten irverify to validate against it. Move PrimTypeID(PrimKind) into ir for the same reason. House the pointer/diag helpers in the shared compiler-support package proposed in #66. Size: S–M.

Acceptance

• Naming.Canonical's grammar has exactly one definition, in Layer 0, and irverify checks conformance to it.
• Primitive TypeIDs are constants/constructors in ir; the OpenAPI compiler and goldens are unchanged behaviorally.

[OmarAlJarrah]

Both halves are now implemented, though not where this issue proposed.

• The naming grammar landed in two steps: compilers: canonical naming grammar diverges across the three compilers #161 fixed the segmentation and added the ir/naming-not-words check to irverify, and refactor: move the naming and ID grammars into the framework #183 moves the single implementation to compilers/compile (compile.CanonicalWords), with an architecture sweep asserting no other package derives a canonical name.
• Primitive IDs are compile.PrimTypeID over a reserved compile.PrimSpace, and refactor: move the naming and ID grammars into the framework #183 moves the rest of the ID grammar — the kind prefixes and the namespace that follows them — alongside it.

The destination is compilers/compile rather than ir, per the framework boundary argued in docs/micro-compiler-design.md §3: the grammar is what every compiler must agree on, and ir stays free of anything a compiler runs. Leaving this open until that substitution is accepted rather than closing it against a destination it did not name.

The remaining gap this issue named — irverify validating full conformance to the grammar rather than the word-sequence shape — is not closed: the check cannot see where a compiler puts boundaries inside a word (foo2bar vs foo_2_bar). That is what the shared implementation and its conformance suite settle instead.

[OmarAlJarrah]

The naming half of this landed as proposed. CanonicalWords moved into ir in #185 and irverify now validates every Naming against it — ir/naming-not-derived — which is the first acceptance bullet as written. The reasoning was this issue's: the architecture sweep that stops a compiler writing its own grammar reaches only this repository's production packages, so a Document decoded from JSON or produced elsewhere was held by nothing.

Two things it did not settle, so this stays open:

• t/prim/<kind> is still compile.PrimTypeID, not a constructor in ir. That is the second acceptance bullet and it is untouched.
• The ID grammar deliberately did not follow. Only the shape — the kind prefixes and the separator — moved to ir, enough for irverify to hold every ID to it. The derivation stayed in compilers/compile because a compiler's path is its own: a JSON Pointer, a GraphQL structural path and a protobuf fully-qualified name are different things and nothing in ir can compute one.