fix(stdlib/E4): carry full author outcome through the bare-TYPE gate (ambiguity at every site)

attempt-4 gated every bare-type-reference site for VISIBILITY via a boolean
leak-check that only caught not-visible and DROPPED the ambiguous outcome, so two
DIRECT flat same-name type authors (the 0755/0105 ambiguity case) fell through to
a global findByName / struct_template_map pick at the non-leaf sites.

Unified author-outcome fix (one path, every site consumes it):

- flatTypeAuthorCount: ≥2 distinct flat authors that do NOT all collapse onto one
  shared TypeId are now `.ambiguous` even when none carries a concrete TypeId yet —
  two same-name GENERIC TEMPLATES (template name registered in no findByName slot)
  are a genuine collision, exactly like two registered structs. Identical-target
  authors (diamond import / two aliases onto the same target) still collapse to
  `.one`, so all valid cases stay byte-identical.

- headTypeGate: the complete source-aware author outcome (.proceed / .resolved /
  .ambiguous / .not_visible) for an unqualified bare TYPE head, emitting the loud
  ambiguity diagnostic (consistent with the leaf / 0755) or the not-visible
  diagnostic. headTypeLeak is now its poison-vs-proceed projection, so every head /
  instantiation / alias-decl / match site poisons on ambiguity with the right
  message. Reflection / type-arg and array/vector-literal identifier heads consume
  `.resolved` to use the source-keyed TypeId, never a global findByName pick.

Regression examples/0767: size_of(Thing) / Nums.[1,2] / Box(s64) / t:Type=Thing /
case Thing: with two direct flat same-name authors each emit the ambiguity
diagnostic, exit 1 (fail-before on bb8f7dc: exit 0 / cascade). 0763/0764/0765/0766
/0755/0706/0544/0105 + FFI byte-identical. README: bare-type ambiguity is enforced
at every reference site.

readme.md

@@ -414,7 +414,12 @@ generic head) — is likewise not visible and is rejected (`type 'X' is not visi
 #import the module that declares it`); qualify it as `m.name`. The type gate holds
 wherever a bare type name is named — a value/field annotation, a reflection /
 type-arg slot (`size_of(T)`, `size_of(*T)`), a typed array-literal head (`T.[…]`),
-or a type-as-value / type-match arm — not just plain annotations. (A library's own *internal* type references still resolve: a generic
+a parameterized head (`Box(s64)`), or a type-as-value / type-match arm — not just
+plain annotations. Ambiguity is enforced at every one of those sites too, exactly
+like a bare call: a bare type that two or more flat imports each declare is
+**ambiguous and rejected** (`type 'X' is ambiguous: it is declared in multiple
+flat-imported modules; qualify the reference or remove the duplicate import`) — never
+a silent pick of one author. (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.)