fix(stdlib/E4): gate unqualified parameterized type heads non-transitively

attempt-3: extend the E4 single-hop bare-TYPE gate to parameterized type
HEADS (the constructor-head analog of the bare-leaf gate). Before this, the
head lookup hit the global struct_template_map / protocol_ast_map /
fn_ast_map *before* any source-aware visibility check, so a 2-flat-hop
imported generic struct/protocol/type-fn remained bare-visible (e.g.
`Box(s64)` when main imports only b.sx and b.sx imports c.sx).

- headTypeLeak: generic-struct / parameterized-protocol heads use the same
  type-author single-hop model as the bare-leaf gate (moduleTypeAuthor +
  flatTypeAuthorCount + localTypeInSource + nameAuthoredAsTypeAnywhere).
- headFnLeak: type-returning-function heads use single-hop function
  visibility (isNameVisible), exempting scope-local mangled type-fns.
- Gated at every unqualified head site: resolveParameterizedWithBindings,
  resolveTypeCallWithBindings, the scanDecls alias-decl dispatch (poisoning
  the alias with .unresolved on leak), resolveArrayLiteralType, and the
  generic-static-method call path. Namespaced (`ns.Box(..)`) heads are an
  explicit qualified reach and stay exempt. Source-pinned instantiation
  (E3/E4) is preserved, so library-internal heads still resolve where they
  are visible.

Regression: examples/0764-modules-import-generic-head-non-transitive
(2-hop `Box(s64)` -> "type 'Box' is not visible", exit 1; direct #import
resolves). Fails-before on a250964 (printed 3), passes-after.

README: note the non-transitive rule covers parameterized type heads.

Gate: zig build 0, zig build test 0 (LSP 522, 423/423), run_examples
505/0, FFI 12xx/13xx/14xx green, 0706/0763/0544/0105 green & byte-identical,
m3te ios-sim build+launch exit 0.

readme.md

@@ -405,10 +405,13 @@ a namespaced alias. That join is **non-transitive for every bare member kind —
 functions, constants, AND types alike**: a flat import of a flat import is NOT
 bare-visible (when `A` imports `B` and `B` imports `C`, `A` does not see `C`'s
 top-level names — including its types — so qualify them, or `#import "C"` directly
-if you reference them). A bare reference to a namespaced-only import's member —
-function, module constant, or **type** — is likewise not visible and is rejected
-(`type 'X' is not visible; #import the module that declares it`); qualify it as
-`m.name`. (A library's own *internal* type references still resolve: a generic
+if you reference them). This holds for a *parameterized* type head too: a generic
+struct / parameterized protocol / type-returning function used as `Box(s64)` is
+gated exactly like a bare leaf type — the constructor head must be reachable over
+your own or a direct flat import, not two hops away. A bare reference to a
+namespaced-only import's member — function, module constant, or **type** (leaf or
+generic head) — is likewise not visible and is rejected (`type 'X' is not visible;
+#import the module that declares it`); qualify it as `m.name`. (A library's own *internal* type references still resolve: a generic
 struct / pack fn / protocol body is instantiated in the module that defines it, so
 e.g. `List(T).append`'s `alloc: Allocator` is visible there regardless of the call
 site.)