P2.2: gravity collapse (pure sx)

Add collapse(board): per-column gravity that packs gems contiguously at
the bottom (preserving top-to-bottom order) and bubbles holes to the top,
with no horizontal movement. Returns whether any gem fell, for the P2.4
cascade. Does not refill (that is P2.3).

tests/collapse.sx snapshots gravity over hand-crafted boards exercising
holes in the middle / at the bottom, a full column of holes, a column
with none, a lone gem, an alternating stack, and an already-settled board
(idempotency). Asserts, independently of the dump, that each column's gems
end packed at the bottom in original order with holes above, plus the
exact moved flag. Golden locked in tests/expected/collapse.{stdout,exit}.

board.sx

@@ -378,3 +378,46 @@ clear_matches :: (board: *Board) -> s64 {
     m := find_matches(board);
     clear_cells(board, @m)
 }
+
+// ── Gravity / collapse (P2.2) ─────────────────────────────────────────────────
+// Second step of the resolution pipeline: let the gems fall into the holes a
+// clear left behind. Within EACH column independently, every gem slides straight
+// down past any holes below it, and the holes bubble to the TOP of the column
+// (the smaller row index, since row 0 is the top of the dump). Columns never
+// exchange gems — there is no horizontal movement. The surviving gems keep their
+// original top-to-bottom order, now packed contiguously at the bottom with all
+// holes contiguous above them. Refilling the freed top holes with fresh gems is
+// P2.3; this step only moves what is already on the board.
+//
+// Returns true iff at least one gem changed row (i.e. some hole had a gem above
+// it). A column that is already settled — or all holes, or all gems — moves
+// nothing, so a fully-settled board returns false; the cascade loop (P2.4) reads
+// this to know when gravity has stopped.
+collapse :: (board: *Board) -> bool {
+    moved := false;
+    for 0..BOARD_COLS: (col) {
+        // Pack this column's gems toward the bottom: scan it bottom-to-top and
+        // write each gem at the falling cursor `w`, which also descends from the
+        // bottom. A gem whose source row differs from `w` actually fell. `w`
+        // never overtakes the read cursor, so writes only land on rows already
+        // read — safe to pack in place.
+        w := BOARD_ROWS - 1;
+        r := BOARD_ROWS - 1;
+        while r >= 0 {
+            g := board.at(col, r);
+            if g != .empty {
+                if r != w { moved = true; }
+                board.set(col, w, g);
+                w -= 1;
+            }
+            r -= 1;
+        }
+        // Every row above the packed gems is now a hole.
+        fill := 0;
+        while fill <= w {
+            board.set(col, fill, .empty);
+            fill += 1;
+        }
+    }
+    moved
+}