std: the prelude becomes a pure re-export facade — implementations move to std/core.sx, std/fmt.sx, std/list.sx

std.sx now contains only alias declarations (the re-export mechanism:
own decls carry one flat-import level) over three part-files: core.sx
(builtins, libc escape hatch, Source_Location/Allocator/Context/Into,
the reserved `string` decl — which needs and permits no alias), fmt.sx
(print/format/any_to_string/string ops/cstring/alloc_slice), list.sx
(List). The namespace tail is unchanged; the part-file namespaces
(core/fmt/list) carry alongside it. Consumer surface is byte-identical
— every bare prelude name resolves through the aliases (0120/0121
machinery). 37 .ir snapshots re-pinned: pure string-constant
renumbering from the changed import graph (digit-normalized diff is
empty). Gates: zig build test 426/426, suite 588/588, m3te 23/23,
game SxChess builds + bundles.

library/modules/std/list.sx

@@ -0,0 +1,46 @@
+// The growable container of the prelude. Consumers never import this file
+// directly — std.sx re-exports `List`.
+#import "modules/std/core.sx";
+
+List :: struct ($T: Type) {
+    items: [*]T = null;
+    len: s64 = 0;
+    cap: s64 = 0;
+
+    append :: (list: *List(T), item: T, alloc: Allocator = context.allocator) {
+        if list.len >= list.cap {
+            new_cap := if list.cap == 0 then 4 else list.cap * 2;
+            new_items : [*]T = xx alloc.alloc_bytes(new_cap * size_of(T));
+            if list.len > 0 {
+                memcpy(new_items, list.items, list.len * size_of(T));
+                alloc.dealloc_bytes(list.items);
+            }
+            list.items = new_items;
+            list.cap = new_cap;
+        }
+        list.items[list.len] = item;
+        list.len += 1;
+    }
+
+    ensure_capacity :: (list: *List(T), n: s64, alloc: Allocator = context.allocator) {
+        if list.cap >= n { return; }
+        new_cap := if list.cap == 0 then 4 else list.cap;
+        while new_cap < n { new_cap = new_cap * 2; }
+        new_items : [*]T = xx alloc.alloc_bytes(new_cap * size_of(T));
+        if list.len > 0 {
+            memcpy(new_items, list.items, list.len * size_of(T));
+            alloc.dealloc_bytes(list.items);
+        }
+        list.items = new_items;
+        list.cap = new_cap;
+    }
+
+    deinit :: (list: *List(T), alloc: Allocator = context.allocator) {
+        if list.items != null {
+            alloc.dealloc_bytes(list.items);
+        }
+        list.items = null;
+        list.len = 0;
+        list.cap = 0;
+    }
+}