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.things/near.ludic

@@ -0,0 +1,26 @@
+# near.ludic - the neighbourhood questions a frame asks many times: what is around a point, of any
+# kind or of one, into a list the CALLER keeps (in its own state, reused every frame), from the grid
+# or the kind's own list - never a walk of every Thing, and nothing allocated or written here
+export function things_near(things_st: ThingsState, x: float, z: float, r: float, out: []Thing) -> int {
+  return tb_within_recs(things_st.th.tab, things_st.th.grid, x, z, r, -1, 0, out)
+}
+
+export function things_near_of(things_st: ThingsState, kind: int, x: float, z: float, r: float, out: []Thing) -> int {
+  return tb_within_of_recs(things_st.th.tab, things_st.th.grid, things_st.th.kinds, x, z, r, kind, out)
+}
+
+# the nearest active Thing within maxr (0: any distance) that `keep` says yes to, or null
+export function thing_nearest_where(things_st: ThingsState, x: float, z: float, maxr: float, keep: fn(Thing) -> bool) -> Thing {
+  let r = tb_nearest_where(things_st.th.tab, things_st.th.grid, x, z, maxr, keep)
+  if r < 0 { return null }
+  return things_st.th.tab.rec[r]
+}
+
+# every one of a kind, active or not, counted and walked without a list
+export function things_count_all_of(things_st: ThingsState, kind: int) -> int { return ix_count(things_st.th.every, kind) }
+
+export function thing_of_kind_all(things_st: ThingsState, kind: int, i: int) -> Thing {
+  let rows = ix_rows(things_st.th.every, kind)
+  if i < 0 or i >= len(rows) { return null }
+  return things_st.th.tab.rec[rows[i]]
+}