refactor: List is slice-backed { items: []T; cap } — directly iterable

items is now a []T slice whose .len IS the live element count (cap = allocated
capacity), so a List iterates directly: `for xs.items (e) { ... }`. A
`len :: (self) -> i64 #get => items.len` accessor keeps `xs.len` reads working;
`.len` WRITES become `.items.len`. List stays 24 bytes (`[]T`=16 + cap=8).

- list.sx: append/ensure_capacity/deinit rewritten for the slice backing. deinit
  guards the free on `cap > 0` (true ownership) and resets via explicit
  ptr=null/len=0 (a `.{}` slice assignment yields a garbage len; `.[]` is the
  empty-slice literal but can't be assigned to a generic []T — both worked around).
- Compiler coupling updated: comptime_vm makeStringList/readStringList write/read
  items as a {ptr,len} fat pointer at field 0 + cap at field 1; control_flow
  listView views an `items: []T` slice (keeps the legacy {[*]T,len} shape too).
- Migrated List `.len` writes to `.items.len` in sched.sx + ui/{render,pipeline,
  glyph_cache} + platform/{sdl3,android,uikit}.
- Snapshots: List's type-table layout changed → ~40 .ir + memory/0800 (items now
  prints as a slice) regenerated; diagnostics/1183 retargeted to a genuine
  many-pointer (xs.items is a slice now). Example memory/0840 locks for-each.

src/ir/comptime_vm.zig

@@ -2516,18 +2516,22 @@ pub const Vm = struct {
         for (items, 0..) |s, i| {
             try self.writeField(table, backing + i * str_size, .string, try self.makeStringValue(table, s));
         }
-        // The List struct: field 0 = items ([*]string), 1 = len (i64), 2 = cap (i64).
+        // The List struct: field 0 = items (`[]string` fat pointer {ptr, len}),
+        // field 1 = cap (i64). `items.ptr` = backing, `items.len` = cap = n.
         const addr = self.machine.allocBytes(table.typeSizeBytes(list_ty), 8);
         const items_fty = table.memberType(list_ty, 0) orelse
             return self.failMsg("comptime List builder: result type has no items field");
-        const len_fty = table.memberType(list_ty, 1) orelse
-            return self.failMsg("comptime List builder: result type has no len field");
-        const cap_fty = table.memberType(list_ty, 2) orelse
+        const cap_fty = table.memberType(list_ty, 1) orelse
             return self.failMsg("comptime List builder: result type has no cap field");
         const n: Reg = @bitCast(@as(i64, @intCast(items.len)));
-        try self.writeField(table, addr + fieldOffset(table, list_ty, 0), items_fty, backing);
-        try self.writeField(table, addr + fieldOffset(table, list_ty, 1), len_fty, n);
-        try self.writeField(table, addr + fieldOffset(table, list_ty, 2), cap_fty, n);
+        // Write the `items` slice as a {ptr, len} fat pointer at field 0.
+        if (items_fty.isBuiltin() or table.get(items_fty) != .slice)
+            return self.failMsg("comptime List builder: items field is not a slice");
+        const items_off = addr + fieldOffset(table, list_ty, 0);
+        try self.machine.writeWord(items_off, table.pointer_size, backing);
+        try self.machine.writeWord(items_off + table.pointer_size, 8, n);
+        // cap = live count (the backing is exactly `n` elements).
+        try self.writeField(table, addr + fieldOffset(table, list_ty, 1), cap_fty, n);
         return addr;
     }
 
@@ -2547,8 +2551,11 @@ pub const Vm = struct {
     fn readStringList(self: *Vm, table: *const types.TypeTable, list_ty: TypeId, addr: Addr) Error![]const []const u8 {
         if (list_ty.isBuiltin() or table.get(list_ty) != .@"struct")
             return self.failMsg("comptime List reader: arg type is not a List struct");
-        const items_ptr = try self.machine.readWord(addr + fieldOffset(table, list_ty, 0), table.pointer_size);
-        const len: usize = @intCast(try self.machine.readWord(addr + fieldOffset(table, list_ty, 1), 8));
+        // `items` is a `[]string` fat pointer at field 0: ptr at offset 0, len
+        // at offset `pointer_size` (there is no separate `len` field now).
+        const items_off = addr + fieldOffset(table, list_ty, 0);
+        const items_ptr = try self.machine.readWord(items_off, table.pointer_size);
+        const len: usize = @intCast(try self.machine.readWord(items_off + table.pointer_size, 8));
         const str_size = table.typeSizeBytes(.string);
         const out = self.gpa.alloc([]const u8, len) catch return self.failMsg("comptime List reader: out of memory");
         var i: usize = 0;