IType: cache free type variables on interned nodes; prune tSubst

[nanavati]

Stacks on #1048 (IType interning); #925 (lift-dictionaries) stacks on this.

What

Interior interned nodes gain a strict VarSet field holding their free type variables,
computed at construction: an ITAp's set is the union of its children's, an
ITForAll's is its body's minus the binder. The intern table is immortal, so the field
is eager (a lazy field would be a permanent thunk) and cheap: union/delete return an
existing set by pointer when one side is empty or the element absent, ground types share
one empty set, and the sets themselves are canonicalized through a content-keyed table
in the same posture as the node table. The field is metadata only — it never serializes,
prints, or participates in comparison or intern keys. fTVars becomes a field read.

tSubstWith now prunes: at each interior node, if the cached free variables are
disjoint from the substitution domain (ctxAvoids), the subtree returns Unchanged
without traversal. The ITForAll case additionally requires the binder not collide with
the payloads' free variables — the original code alpha-converts there even when the body
contains no domain variable, and that rename is observable, so it falls through to the
original logic.

The chicken switch

One hidden flag, -hack-no-itype-ftv-cache, disables both the cache and the pruning in
one binary: nodes store a single shared empty set (so the flag also measures the field's
own residency cost), fTVarSet walks instead of reading the field, and the substitution
machinery takes the exact pre-cache code paths, including the gratuitous binder renames
the pruning otherwise skips. The pruning guards are gated on the flag itself, never on
the cached sets (a dummy empty set consulted by a guard would prune everything), and
capture detection goes through fTVarSet, which walks in disabled mode — so it stays
exact either way.

Validation

• The flag gating was audited to be total: every consumer of the cached sets is behind
  it, and the disabled path is the pre-cache code, not an approximation of it.
• The two flag states produce fully compatible output. The cached sets themselves never
  serialize; the only output difference is alpha-naming of forall binders inside
  serialized types (the pruning skips the pre-cache walk's gratuitous renames of
  binders in subtrees a substitution cannot change). That naming is semantically
  neutral — every compiler dump is byte-identical between the states, and binders are
  freshly instantiated at every use — so .bo files from either state are valid and
  mutually readable. (Mixing states across packages can at worst miss a
  sharing/dedup opportunity, since type comparison is nominal on binder names; it can
  never produce a wrong result.)
• No benchmarks have been run. The flag exists precisely so the optimization can be
  measured A/B on real workloads with a single binary; measurements on more real-world
  examples are of interest.