lang: qualified namespace members in value position + alias carry

Two coupled capabilities on the road to the std restructure
(current/PLAN-STDLIB.md, issue 0114):

1. alias.Type.method() / alias.Type as a call head, alias.CONST, and
   alias.Enum.variant now resolve — previously only alias.fn() and
   type-position alias.Type worked. objectIsValue treats an
   alias-rooted field_access as a type head; the call path strips the
   alias to the existing Type.method machinery; lowerFieldAccess
   resolves alias.CONST pinned to the target module and alias.Enum.x
   as a typed enum literal; resolveTypeWithBindings resolves qualified
   type_exprs pinned to the target.

2. The carry rule: namespaceAliasTarget resolves an alias from the
   file's own edges first, then from DIRECT flat imports (one level),
   diagnosing two distinct carried targets as ambiguous. All qualified
   shapes work through a carried alias — the std.sx namespace tail
   (mem.GPA.init() etc.) is now expressible.

Regression: examples/0831-modules-namespace-alias-carry.sx (direct +
carried, all seven shapes).

src/ir/lower/call.zig

@@ -699,6 +699,9 @@ pub fn lowerCall(self: *Lowering, c_in: *const ast.Call) Ref {
                 const ns_name: ?[]const u8 = switch (fa.object.data) {
                     .identifier => |id| id.name,
                     .type_expr => |te| te.name,
+                    // `alias.Type.method()` — strip the alias so the existing
+                    // `Type.method` qualified machinery resolves the static.
+                    .field_access => self.namespaceRootedMember(fa.object),
                     else => null,
                 };
                 const qualified_name = if (ns_name) |n|