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`.

src/ir/lower.zig

@@ -5329,6 +5329,7 @@ pub const Lowering = struct {
                                     const ret_ty = func.ret;
                                     const params = func.params;
                                     self.fixupMethodReceiver(&method_args, func, effective_obj_node, obj_ty);
+                                    self.appendDefaultArgs(fd, &method_args);
                                     const final_args = self.prependCtxIfNeeded(func, method_args.items);
                                     self.coerceCallArgs(final_args, params);
                                     return self.builder.call(fid, final_args, ret_ty);
@@ -7971,6 +7972,23 @@ pub const Lowering = struct {
         return false;
     }
 
+    /// After args have been lowered, append the lowered values of any
+    /// `param: T = default_expr` defaults for positions past `args.items.len`.
+    /// Stops at the first param without a default. Used at method-dispatch
+    /// sites whose callee is a field_access (so `expandCallDefaults` can't
+    /// handle them up front). The default expression is lowered in the
+    /// caller's current scope, so identifiers like `context.allocator`
+    /// resolve to the caller's runtime context.
+    fn appendDefaultArgs(self: *Lowering, fd: *const ast.FnDecl, args: *std.ArrayList(Ref)) void {
+        if (args.items.len >= fd.params.len) return;
+        var i: usize = args.items.len;
+        while (i < fd.params.len) : (i += 1) {
+            const dflt = fd.params[i].default_expr orelse break;
+            const v = self.lowerExpr(dflt);
+            args.append(self.alloc, v) catch unreachable;
+        }
+    }
+
     /// When a bare-identifier call omits trailing positional args and the
     /// callee's signature provides defaults for them, return a fresh Call
     /// node with the defaults filled in. Returns null when no expansion is