feat(stdlib): per-decl nominal identity + same-name shadows — close 0105 [stdlib E2]

Make same-name top-level types in different sources DISTINCT nominal types
instead of collapsing last-wins in the type table (issue 0105).

Registration:
- internNamedTypeDecl assigns a per-decl nominal_id and populates
  type_decl_tids. The first author of a name keeps nominal_id 0 (byte-identical
  to pre-E2); a genuine cross-module shadow (>=2 distinct normalized-path
  authors per the import facts) gets a fresh id -> a distinct TypeId.
- mergeFlat/addOwnDecl stop first-wins-dropping per-source decls (named types +
  non-fn const_decls) so every same-name author reaches registration; functions
  and var_decls (incl. #foreign extern globals) keep first-wins.

Resolution (selectNominalLeaf):
- own-author wins; else flatTypeAuthorCount over the transitive flat closure:
  >=2 distinct -> .ambiguous (loud diagnostic + poison); exactly one -> resolved;
  a flat author not yet findByName-registered -> .undeclared stub (not a leak).
- struct-literal type names route through the same source-aware leaf.
- lazyLowerFunction pins the function's own source before resolving its return
  type, so a shadowed signature type resolves in its module, not the caller's.

Codegen:
- mangleTypeName appends __n<id> for nonzero nominal_id so same-name shadows get
  distinct monomorph symbols (struct_to_string__Box vs __Box__n1).

Library hygiene:
- rename trace.sx's compiler-contracted Frame -> TraceFrame (+ the two compiler
  findByName sites) so it never collides with a UI/geometry Frame; the layout is
  structural (getFrameStructType / SxFrame), name-independent.

Examples: 0752-0756 pin the five 0105 cases (distinct fields / same fields /
own-wins / ambiguous / alias per-source); 0170 pins the folded anon-struct-field
regression.

src/imports.zig

@@ -313,7 +313,11 @@ pub const ResolvedModule = struct {
             if (self.scope.contains(name)) return false;
             try self.scope.put(name, {});
             if (seen_list.contains(name)) {
-                append_to_global = false;
+                // A cross-module name collision: drop from the global list
+                // (first-wins) UNLESS this is a per-source decl (type / alias /
+                // const), which must reach registration as a distinct author of
+                // its own module (issues 0104/0105).
+                append_to_global = isPerSourceDecl(decl);
             } else {
                 try seen_list.put(name, {});
             }
@@ -346,14 +350,42 @@ pub const ResolvedModule = struct {
         for (other.decls) |decl| {
             if (seen_nodes.contains(decl)) continue;
             if (decl.data.declName()) |name| {
-                if (seen_list.contains(name)) continue;
-                try seen_list.put(name, {});
+                if (seen_list.contains(name)) {
+                    // First-wins on a cross-module name collision — EXCEPT a
+                    // per-source decl (type / alias / const), each of which must
+                    // reach registration as a distinct same-name author of its own
+                    // module (issues 0104/0105). Only FUNCTIONS keep first-wins
+                    // (issue 0102 — the shadowed author stays reachable via its
+                    // qualified name / SelectedFunc). Node identity (above) still
+                    // de-dups a diamond import of the SAME decl.
+                    if (!isPerSourceDecl(decl)) continue;
+                } else {
+                    try seen_list.put(name, {});
+                }
             }
             try seen_nodes.put(decl, {});
             try list.append(allocator, decl);
         }
     }
 
+    /// A decl that must register PER-SOURCE: each same-name author across modules
+    /// registers against its OWN module rather than collapsing to a single
+    /// first-wins winner. NAMED types and non-function `const_decl`s (type
+    /// aliases + value consts, source-keyed via the alias/const caches) are
+    /// per-source — that is what closes issues 0104/0105. Everything else keeps
+    /// the first-wins name-merge: FUNCTIONS (issue 0102 — the shadowed author
+    /// stays reachable via its qualified name / SelectedFunc), and crucially
+    /// `var_decl`s, including a `#foreign` extern global declared in two files
+    /// (e.g. `__stdinp : *void #foreign;`) that MUST resolve to the ONE libSystem
+    /// symbol, not split into a duplicate `__stdinp.1`.
+    fn isPerSourceDecl(decl: *const Node) bool {
+        return switch (decl.data) {
+            .struct_decl, .enum_decl, .union_decl, .error_set_decl, .protocol_decl, .foreign_class_decl => true,
+            .const_decl => |cd| cd.value.data != .fn_decl,
+            else => false,
+        };
+    }
+
     /// Add another module as a namespaced import. The alias `name` becomes
     /// part of this module's own decls (so a flat-importer of this module
     /// sees the alias one hop out — matching authored names).