mem: List(T) mutations gain optional alloc: Allocator = context.allocator

The chess panel-text regression (text vanished after the first move on
macOS) had a single root cause: GlyphCache's entries List, hash table,
and shaped_buf grew through `context.allocator` — which during render
is the per-frame arena. On the next arena reset the backing died, and
subsequent glyph lookups read garbage / wrote into freshly-allocated
view-tree memory.

Fix is shaped as the user proposed: `List(T)`'s mutations take an
optional trailing `alloc: Allocator = context.allocator` argument. No
allocator stored on the container, no init ceremony, every existing
`list.append(item)` callsite keeps working unchanged. Long-lived
owners now write `list.append(item, self.parent_allocator)` and the
arena-leak bug becomes impossible to write accidentally.

Default-arg substitution previously only fired for identifier callees
(`expandCallDefaults` at lower.zig:7978). Extended to the generic
struct-method dispatch path (`list.append(...)` lands here) via a new
`appendDefaultArgs` helper that lowers fd.params[i].default_expr in
the caller's scope and appends to the lowered args slice.

Long-lived owners updated to capture `parent_allocator: Allocator` at
init and use it for every internal growth:

- GlyphCache (the chess bug) — entries, shaped_buf, hash_keys,
  hash_vals, atlas bitmap.
- DockInteraction — drops the existing `push Context` workaround in
  `ensure_capacity` for the explicit-arg form.
- StateStore — entries list + per-entry data buffer.
- Gles3Gpu, MetalGPU — shaders, buffers, textures (atlas-grow during
  render would otherwise leak resources into the frame arena).

Also kept: an operator-precedence fix in pipeline.sx
(`(self.frame_index & 1) == 0` instead of
`self.frame_index & 1 == 0`, which parses as
`self.frame_index & (1 == 0)` = always 0). That was a stealth
single-arena-only bug that masked the GlyphCache one for a long time.

Docs:
- specs.md §11 documents `param: T = expr` default parameter values.
  The parser already supported it — formalised in the spec now.
- current/CHECKPOINT-MEM.md logs the change.
- CLAUDE.md REJECTED PATTERNS gains a "Long-lived containers growing
  through context.allocator" section with the `parent_allocator`
  capture template and the list of existing examples to mirror.

155/155 example tests pass — zero-diff against snapshots since every
existing callsite still resolves to `context.allocator`.

library/modules/std.sx

@@ -408,13 +408,13 @@ List :: struct ($T: Type) {
     len: s64 = 0;
     cap: s64 = 0;
 
-    append :: (list: *List(T), item: T) {
+    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 context.allocator.alloc(new_cap * size_of(T));
+            new_items : [*]T = xx alloc.alloc(new_cap * size_of(T));
             if list.len > 0 {
                 memcpy(new_items, list.items, list.len * size_of(T));
-                context.allocator.dealloc(list.items);
+                alloc.dealloc(list.items);
             }
             list.items = new_items;
             list.cap = new_cap;
@@ -422,4 +422,26 @@ List :: struct ($T: Type) {
         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(new_cap * size_of(T));
+        if list.len > 0 {
+            memcpy(new_items, list.items, list.len * size_of(T));
+            alloc.dealloc(list.items);
+        }
+        list.items = new_items;
+        list.cap = new_cap;
+    }
+
+    deinit :: (list: *List(T), alloc: Allocator = context.allocator) {
+        if list.items != null {
+            alloc.dealloc(list.items);
+        }
+        list.items = null;
+        list.len = 0;
+        list.cap = 0;
+    }
 }