Generate compiler option definitions, create JSON schema - #64457

Single-file transpilation must ignore options that only make sense for
whole-program builds. Keeping a separate clearing list lets it drift
from the existing transpile metadata whenever options are added.

Derive the clearing list from that metadata while leaving mode-specific
overrides and conditional behavior in the transpile worker.

Option enums and SyntaxKind already have authoritative metadata. Reading
generated Go back into the TypeScript generator adds an unnecessary
intermediate representation and points contributors at the wrong source.

Use those definitions directly while retaining one shared enum emitter
and Go-value verification for every input source.

Ship version-matched configuration schemas with the main package so tools
can use the installed compiler version without relying on a hosted schema.

Draft-07 ignores siblings of a reference. Keep root option descriptions
outside the reference so consumers retain their documentation and links.

Keep the distinction between build options and compiler options visible
in the generated struct, as it was before generation.

…ptions

Option metadata already identifies which fields affect diagnostics, emit,
declaration paths, and build info. Use it to avoid runtime reflection
without maintaining another handwritten list of fields.

Preserve effective strict defaults and build-info ordering and zero-value
semantics, with the previous reflection logic retained as a test oracle.

The option metadata already describes every field and its JSON name.
Use it to avoid reflective field access and tag parsing during config
merging while keeping new options covered automatically.

Preserve explicit-null overrides, nonzero source precedence, and shallow
sharing of slices and pointers.

Reduce handwritten serialization machinery by deriving field handling
and enum names from the existing option metadata. This keeps option
coverage centralized and makes field access statically checked rather
than relying on reflection and runtime assertions.

Preserve output ordering, enum aliases, and unset-value behavior while
retaining handwritten formatting helpers and implied-option rules.

Keep whole-options equality aligned with the option definitions without
runtime reflection. Preserve stored values, pointer contents, collection
ordering, and nil-versus-empty distinctions.

Compare paths by their ordered entries rather than ordered-map backing
storage, so allocation history does not cause spurious project changes.

Aggregate reflection bypassed compiler option equality, making watch mode
sensitive to ordered-map backing storage that the project system ignores.
Compose option equality methods so both callers honor the same semantics.

Treat absent and empty type acquisition lists alike, matching their
existing acquisition behavior, while retaining other presence and order
distinctions.

Per-feature outputs fragmented related option code across too many files.
Group generated code by package, retaining a separate declarations file
in tsoptions, and keep compiler option tests together.

This reduces file proliferation without changing generated declarations
or test coverage.