lang migration: rename signed integer types sN -> iN

Mechanical sweep of all .sx sources, plan docs, and tests/expected
snapshots for the sx language rename (s8/s16/s32/s64 -> i8/i16/i32/i64).
Verified: tools/run_tests.sh 23/23.

Note: the ios-sim build has 2 pre-existing 'restart' dot-call errors
from the sx opt-in UFCS change (sx a47ea14) — independent of this
rename (present pre-sweep); migrated in the follow-up commit.

board_anim.sx

@@ -109,7 +109,7 @@ bad_swap_bounce :: (t: f32) -> f32 {
 // ease_in_cubic so each column still accelerates under gravity within its window.
 // `tests/easing.sx` pins f(0)=0, f(1)=1, monotonicity, and the cascade ordering.
 FALL_STAGGER_MAX :f32: 0.30;
-fall_stagger_t :: (t: f32, col: s64) -> f32 {
+fall_stagger_t :: (t: f32, col: i64) -> f32 {
     delay := FALL_STAGGER_MAX * (cast(f32) col / cast(f32) (BOARD_COLS - 1));
     window := 1.0 - FALL_STAGGER_MAX;
     lt := (t - delay) / window;
@@ -123,7 +123,7 @@ fall_stagger_t :: (t: f32, col: s64) -> f32 {
 // at `1 - FALL_STAGGER_MAX`; the last column lands exactly at 1.0. The landing
 // squash-bounce (P17.3) ages from this instant per column, so the squash begins
 // the moment a gem touches its cell rather than at a flat whole-row settle.
-fall_landing_frac :: (col: s64) -> f32 {
+fall_landing_frac :: (col: i64) -> f32 {
     (1.0 - FALL_STAGGER_MAX) + FALL_STAGGER_MAX * (cast(f32) col / cast(f32) (BOARD_COLS - 1))
 }
 
@@ -132,7 +132,7 @@ fall_landing_frac :: (col: s64) -> f32 {
 // per-round bounce ages from. Round k's fall starts after the swap, k clear+fall
 // pairs, and that round's own clear; column `col` then lands `fall_landing_frac`
 // of the fall window into it. Pure + headless, mirrors `phase`'s segment walk.
-round_land_time :: (k: s64, col: s64) -> f32 {
+round_land_time :: (k: i64, col: i64) -> f32 {
     SWAP_ANIM_DUR + cast(f32) k * (CLEAR_ANIM_DUR + FALL_ANIM_DUR) + CLEAR_ANIM_DUR
         + fall_landing_frac(col) * FALL_ANIM_DUR
 }
@@ -159,10 +159,10 @@ clear_ripple_t :: (t: f32, u: f32) -> f32 {
 
 // The diagonal (col+row) extent of a round's matched cells — the span the ripple
 // ranks each matched gem across. `hi < lo` only if the mask is empty.
-ClearDiag :: struct { lo: s64; hi: s64; }
+ClearDiag :: struct { lo: i64; hi: i64; }
 clear_diag_span :: (m: *MatchMask) -> ClearDiag {
-    lo : s64 = (BOARD_COLS - 1) + (BOARD_ROWS - 1) + 1;
-    hi : s64 = -1;
+    lo : i64 = (BOARD_COLS - 1) + (BOARD_ROWS - 1) + 1;
+    hi : i64 = -1;
     for 0..BOARD_CELLS (i) {
         if m.cells[i] {
             d := (i % BOARD_COLS) + (i / BOARD_COLS);
@@ -178,7 +178,7 @@ clear_diag_span :: (m: *MatchMask) -> ClearDiag {
 // PER ROUND (not across the board) lets even a small 3-match ripple across the
 // full stagger budget. A degenerate span (every matched cell on one diagonal)
 // ranks all gems 0, so they pop together rather than dividing by zero.
-clear_rank :: (span: ClearDiag, col: s64, row: s64) -> f32 {
+clear_rank :: (span: ClearDiag, col: i64, row: i64) -> f32 {
     if span.hi <= span.lo { return 0.0; }
     cast(f32) ((col + row) - span.lo) / cast(f32) (span.hi - span.lo)
 }
@@ -193,7 +193,7 @@ clear_rank :: (span: ClearDiag, col: s64, row: s64) -> f32 {
 AnimRound :: struct {
     before: [BOARD_CELLS]Gem;
     matched: MatchMask;
-    src: [BOARD_CELLS]s64;
+    src: [BOARD_CELLS]i64;
     after: [BOARD_CELLS]Gem;
 }
 
@@ -210,7 +210,7 @@ AnimMove :: struct {
     pre: [BOARD_CELLS]Gem;
     rounds: List(AnimRound);
     final: [BOARD_CELLS]Gem;
-    awarded: s64;
+    awarded: i64;
 }
 
 // The most recent round at or before `kmax` that dropped a MOVED gem onto
@@ -221,7 +221,7 @@ AnimMove :: struct {
 // ages from its LATEST arrival, never a stale earlier one. Pure + headless: the
 // per-round bounce (render_fall/clear) and the final-settle stamp share this so
 // one envelope plays continuously across every seam.
-delivering_round :: (mv: *AnimMove, i: s64, kmax: s64) -> s64 {
+delivering_round :: (mv: *AnimMove, i: i64, kmax: i64) -> i64 {
     row := i / BOARD_COLS;
     k := kmax;
     while k >= 0 {
@@ -312,7 +312,7 @@ AnimPhaseKind :: enum { swap; clear; fall; done; }
 
 AnimPhase :: struct {
     kind: AnimPhaseKind;
-    round: s64;
+    round: i64;
     t: f32;
 }
 
@@ -327,7 +327,7 @@ BoardAnim :: struct {
     // so the frame loop's per-round SFX is edge-triggered: a round's cue fires once,
     // when its clear begins, never re-fired every frame. Reset whenever a move
     // (re)starts; advanced by the frame loop as rounds clear.
-    cascade_fired: s64;
+    cascade_fired: i64;
 
     init :: (self: *BoardAnim) {
         self.active = false;
@@ -383,11 +383,11 @@ BoardAnim :: struct {
 // have fired by now (clamped to the move's round count). The frame loop diffs it
 // against `BoardAnim.cascade_fired` to play one cue per newly-cleared round. Pure +
 // headless so the per-round playback is snapshot-testable without audio.
-cascade_rounds_started :: (elapsed: f32, num_rounds: s64) -> s64 {
+cascade_rounds_started :: (elapsed: f32, num_rounds: i64) -> i64 {
     if num_rounds <= 0 { return 0; }
     if elapsed < SWAP_ANIM_DUR { return 0; }
     seg := CLEAR_ANIM_DUR + FALL_ANIM_DUR;
-    started := cast(s64) ((elapsed - SWAP_ANIM_DUR) / seg) + 1;
+    started := cast(i64) ((elapsed - SWAP_ANIM_DUR) / seg) + 1;
     if started > num_rounds { return num_rounds; }
     started
 }