feat(ecs): ludic.base Table<T> - dense rows of hot columns, generational handles, a spatial grid, kind indexes and an id map kept current by the setters; ludic.things on it

A mechanic that keeps many of something keeps them as rows of a Table<T> rather than a list it
scans. Removal swaps the last row in; a handle (22-bit slot, 9-bit generation) goes stale when its
entity is removed. tb_set_f / tb_set_xz / tb_set_i stamp a change tick and refile the row in every
index over that column in O(1): tb_grid (a doubly linked spatial hash, rings outward for nearest,
rehashing as it grows), tb_index (a cached query: the rows of each value of a kind column, gated by
an active column), tb_nearest_of / tb_within_of (a rare kind from its own list), tb_nearest_where
(a predicate on the record), tb_within_recs (into the caller's list), tb_changed_since /
tb_added_since, IntMap. No question allocates or writes: Ludic frees nothing, and the old lists'
per-call copies leaked every frame.

ludic.things keeps its Things as a Table<Thing> with x, z, kind and active as columns; every verb
writes the record and the row together (a Thing carries its handle and table, so thing_hide(t)
still needs no state), thing_set_on / thing_set_xz / thing_place_at are the silent forms the game
used to do by assignment, and things_verify holds the columns against the records.
things_near(_of) fill a caller's list, thing_of_kind walks a kind, things_count_of counts one, and
things_tick visits only the kinds that tick. thing_find answers the first-placed by uid.

Against a []Record scanned (M4 Pro): nearest 0.37 / 1.5 / 7.2 us at 10k / 100k / 1M (list 30 /
307 / 3075), by id 0.09 us at 100k (list 17), a move refiled in 11-44 ns. ecs_fuzz_test holds the
grid, the kind index and the record queries against a scan through 9000 random changes.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

packages/ludic.base/ecs_grid_within.ludic

@@ -0,0 +1,48 @@
+# ludic.base/ecs_grid_within.ludic - every filed row within r of (x, z) matching (mc, mv), into
+# `out` (cleared first), in no order; the count is returned. A radius wider than the rows are many
+# is answered by one scan of them instead of by cells.
+export function tb_within<T>(tb: Table<T>, g: Grid, x: float, z: float, r: float, mc: int, mv: int, out: words) -> int {
+  List.clear(out)
+  if g.count == 0 { return 0 }
+  var mcol: words = null
+  if mc >= 0 { mcol = tb.i[mc] }
+  let xs = tb.f[g.cx]
+  let zs = tb.f[g.cz]
+  let ix0 = grid_cell(g, x - r)
+  let ix1 = grid_cell(g, x + r)
+  let iz0 = grid_cell(g, z - r)
+  let iz1 = grid_cell(g, z + r)
+  let cells = (ix1 - ix0 + 1) * (iz1 - iz0 + 1)
+  if cells > g.count or cells < 0 {
+    grid_within_scan(g, xs, zs, mcol, mv, x, z, r * r, out)
+    return len(out)
+  }
+  for ix in ix0 .. ix1 + 1 {
+    for iz in iz0 .. iz1 + 1 { grid_within_cell(g, xs, zs, mcol, mv, x, z, r * r, ix, iz, out) }
+  }
+  return len(out)
+}
+
+function grid_within_cell(g: Grid, xs: floats, zs: floats, mcol: words, mv: int, x: float, z: float, r2: float, ix: int, iz: int, out: words) -> void {
+  let k = grid_key(ix, iz)
+  var r = g.head[grid_bucket(g, ix, iz)]
+  while r > 0 {
+    let row = r - 1
+    if g.key[row] == k and (mcol == null or mcol[row] == mv) {
+      let dx = xs[row] - x
+      let dz = zs[row] - z
+      if dx * dx + dz * dz <= r2 { push(out, row) }
+    }
+    r = g.next[row]
+  }
+}
+
+function grid_within_scan(g: Grid, xs: floats, zs: floats, mcol: words, mv: int, x: float, z: float, r2: float, out: words) -> void {
+  for row in 0 .. len(g.key) {
+    if g.key[row] >= 0 and (mcol == null or mcol[row] == mv) {
+      let dx = xs[row] - x
+      let dz = zs[row] - z
+      if dx * dx + dz * dz <= r2 { push(out, row) }
+    }
+  }
+}