lang: generic struct head aliases bind the template (fix 0120) — alias-follow from each author's source in head selection; loud unknown-type on the .call type tail

BoxAlias :: Box; / Box :: r.Box; now resolve instantiation, methods,
annotations, and chains through the aliased template, and re-export one
flat-import level as ordinary own decls (the facade shape the std.sx
restructure needs). selectGenericStructHead consults aliasedStructTemplate
(nominal.zig) before the global template map — own-wins/single-flat alias
author, each hop pinned to the alias author's source, ns.X RHS through
namespaceAliasVerdictFrom, depth-capped. resolveTypeCallWithBindings'
silent .unresolved tail (panicked in LLVM emission) now diagnoses
"unknown type". Also aligns the stale pre-existing calls.test.zig UFCS
plan test with the opt-in model (a47ea14). Regression: examples/0211
(+rich/+facade). Gates: zig build test 426/426, suite 587/587.

examples/0211-generics-struct-alias-head-facade.sx

@@ -0,0 +1,9 @@
+// Companion of 0211: the re-export facade — own alias decls over another
+// module's members. Flat importers of THIS file see the aliases bare.
+#import "modules/std.sx";
+
+r :: #import "0211-generics-struct-alias-head-rich.sx";
+
+helper :: r.helper;
+Thing :: r.Thing;
+Box :: r.Box;

examples/0211-generics-struct-alias-head-rich.sx

@@ -0,0 +1,15 @@
+// Companion of 0211: the authoring module — a plain fn, a plain struct,
+// and a generic struct, all re-exported by -facade.sx via alias decls.
+#import "modules/std.sx";
+
+helper :: () -> s64 { 7 }
+
+Thing :: struct {
+    v: s64;
+    init :: () -> Thing { Thing.{ v = 42 } }
+}
+
+Box :: struct ($T: Type) {
+    item: T;
+    get :: (b: *Box(T)) -> T { b.item }
+}

examples/0211-generics-struct-alias-head.sx

@@ -0,0 +1,43 @@
+// Generic-struct head aliases: `BoxAlias :: Box;` binds the alias to the
+// SAME template — instantiation, methods, annotations, and alias chains all
+// resolve through it. Cross-module, a facade's `Box :: r.Box;` re-export is
+// the facade's OWN declaration, so it carries one flat-import level exactly
+// like a plain-struct alias (companion files: -rich.sx authors the decls,
+// -facade.sx re-exports them through a namespace alias).
+// Regression (issue 0120): the alias head used to lower silently to an
+// unresolved type and panic in the LLVM backend at instantiation.
+#import "modules/std.sx";
+#import "0211-generics-struct-alias-head-facade.sx";
+
+LocalBox :: struct ($T: Type) {
+    item: T;
+    get :: (b: *LocalBox(T)) -> T { b.item }
+}
+
+LocalAlias :: LocalBox;
+ChainAlias :: LocalAlias;
+
+main :: () {
+    // Same-file alias: instantiation + field + method.
+    b := LocalAlias(s64).{ item = 3 };
+    print("field: {}\n", b.item);
+    print("method: {}\n", b.get());
+
+    // Alias chain terminates at the template.
+    c := ChainAlias(s64).{ item = 11 };
+    print("chain: {}\n", c.item);
+
+    // Alias as a type annotation head.
+    a : LocalAlias(string) = .{ item = "ann" };
+    print("annot: {}\n", a.item);
+
+    // Cross-module re-exports carried one flat hop from the facade:
+    // plain fn, plain struct (static method), and the generic head.
+    print("helper: {}\n", helper());
+    t := Thing.init();
+    print("thing: {}\n", t.v);
+    f := Box(s64).{ item = 7 };
+    print("facade: {}\n", f.get());
+    x : Box(string) = .{ item = "qq" };
+    print("facade-annot: {}\n", x.item);
+}

examples/expected/0211-generics-struct-alias-head.exit

@@ -0,0 +1 @@
+0

examples/expected/0211-generics-struct-alias-head.stderr

@@ -0,0 +1 @@
+

examples/expected/0211-generics-struct-alias-head.stdout

@@ -0,0 +1,8 @@
+field: 3
+method: 3
+chain: 11
+annot: ann
+helper: 7
+thing: 42
+facade: 7
+facade-annot: qq