lang: rename signed integer types sN -> iN

Surface rename of the signed integer family: s1..s64 become i1..i64
(u1..u64, usize, isize unchanged). 'string' keeps the s-prefix arm in
name classification; width parsing moves to the i-prefix arm next to
isize.

Internal TypeId tags follow the surface (.s8/.s16/.s32/.s64 ->
.i8/.i16/.i32/.i64), as do mono-key mangle fragments (ptr_i64,
tu_i64_bool) and all display/diagnostic formatting (i{d}).

Migrated in the same sweep: stdlib + examples + issue repros + FFI C
companions (shared symbol names like ffi_id_i64), expected
stdout/stderr/ir snapshots, specs.md, readme.md, CLAUDE.md/AGENTS.md,
implementation_plan.md, docs/, issue writeups. Vendored stb_image and
historical flow state left untouched.

zig build test: 426/426; examples suite: 595/595.

examples/0121-types-types.sx

@@ -4,7 +4,7 @@
 #import "modules/std/test.sx";
 pkg :: #import "tests/fixtures/testpkg";
 
-Point :: struct { x, y: s32; }
+Point :: struct { x, y: i32; }
 
 Color :: enum { red; green; blue; }
 
@@ -16,7 +16,7 @@ Shape :: enum {
 
 Overlay :: union {
     f: f32;
-    i: s32;
+    i: i32;
 }
 
 Vec2 :: union {
@@ -25,27 +25,27 @@ Vec2 :: union {
 }
 
 Defaults :: struct {
-    a: s32;
-    b: s32 = 99;
-    c: s32 = ---;
+    a: i32;
+    b: i32 = 99;
+    c: i32 = ---;
 }
 
 MyFloat :: f64;
 
 Status :: enum u8 { ok; err; timeout; }
 
-add :: (a: s32, b: s32) -> s32 { a + b }
+add :: (a: i32, b: i32) -> i32 { a + b }
 
-mul :: (a: s32, b: s32) -> s32 { a * b }
+mul :: (a: i32, b: i32) -> i32 { a * b }
 
 vec3 :: (x: f32, y: f32, z: f32) -> Vector(3, f32) {
     .[x, y, z]
 }
 
 // Global variable for address-of test
-g_smoke_val : s32 = 42;
+g_smoke_val : i32 = 42;
 
-write_to_ptr :: (p: *s32) {
+write_to_ptr :: (p: *i32) {
     p.* = 99;
 }
 
@@ -57,15 +57,15 @@ main :: () {
     print("=== 3. Types ===\n");
 
     // Primitive types
-    v_s8 : s8 = 127;
-    v_s16 : s16 = 32000;
-    v_s32 : s32 = 100000;
+    v_i8 : i8 = 127;
+    v_i16 : i16 = 32000;
+    v_i32 : i32 = 100000;
     v_u8 : u8 = 255;
     v_u16 : u16 = 65000;
     v_u32 : u32 = 4000000;
-    print("s8: {}\n", v_s8);
-    print("s16: {}\n", v_s16);
-    print("s32: {}\n", v_s32);
+    print("i8: {}\n", v_i8);
+    print("i16: {}\n", v_i16);
+    print("i32: {}\n", v_i32);
     print("u8: {}\n", v_u8);
     print("u16: {}\n", v_u16);
     print("u32: {}\n", v_u32);
@@ -88,8 +88,8 @@ main :: () {
     print("struct-named: {}\n", p3);
 
     // Shorthand (variable name = field name)
-    x : s32 = 5;
-    y : s32 = 6;
+    x : i32 = 5;
+    y : i32 = 6;
     p4 := Point.{ x, y };
     print("struct-shorthand: {}\n", p4);
 
@@ -226,7 +226,7 @@ main :: () {
     o : Overlay = ---;
     o.f = 3.14;
     print("union-f: {}\n", o.f);
-    // Type punning — read same bits as s32
+    // Type punning — read same bits as i32
     print("union-i: {}\n", o.i);
 
     // Union member promotion
@@ -237,22 +237,22 @@ main :: () {
     print("promoted-data0: {}\n", uv.data[0]);
 
     // --- Arrays ---
-    arr : [5]s32 = .[10, 20, 30, 40, 50];
+    arr : [5]i32 = .[10, 20, 30, 40, 50];
     print("arr[2]: {}\n", arr[2]);
     print("arr.len: {}\n", arr.len);
 
     // Array element assignment
-    aa : [3]s32 = .[1, 2, 3];
+    aa : [3]i32 = .[1, 2, 3];
     aa[1] = 99;
     print("arr-assign: {}\n", aa);
 
     // --- Slices ---
-    sl : []s32 = .[1, 2, 3, 4, 5];
+    sl : []i32 = .[1, 2, 3, 4, 5];
     print("sl[0]: {}\n", sl[0]);
     print("sl.len: {}\n", sl.len);
 
     // Slice element write
-    sla : []s32 = .[10, 20, 30];
+    sla : []i32 = .[10, 20, 30];
     sla[1] = 55;
     print("sl-assign: {}\n", sla);
 
@@ -265,7 +265,7 @@ main :: () {
     print("tail: {}\n", tail);
 
     // Slice of slice
-    sos : []s32 = .[10, 20, 30, 40, 50];
+    sos : []i32 = .[10, 20, 30, 40, 50];
     mid := sos[1..4];
     inner := mid[0..2];
     print("slice-of-slice: {}\n", inner);
@@ -289,18 +289,18 @@ main :: () {
     print("auto-deref: {}\n", ptr.x);
 
     // Many-pointer
-    mp : [*]s32 = @arr[0];
+    mp : [*]i32 = @arr[0];
     print("mp[0]: {}\n", mp[0]);
     print("mp[3]: {}\n", mp[3]);
 
     // Many-pointer write
-    mpw : [5]s32 = .[10, 20, 30, 40, 50];
-    mpw_ptr : [*]s32 = @mpw[0];
+    mpw : [5]i32 = .[10, 20, 30, 40, 50];
+    mpw_ptr : [*]i32 = @mpw[0];
     mpw_ptr[2] = 99;
     print("mp-write: {}\n", mpw[2]);
 
     // Pointer-null comparison
-    np : *s32 = null;
+    np : *i32 = null;
     print("ptr==null: {}\n", np == null);
     print("ptr!=null: {}\n", np != null);
     np2 := @pv.x;
@@ -309,13 +309,13 @@ main :: () {
 
     // Pointer to nested struct field
     Inner3 :: struct { a: f32; b: f32; c: f32; }
-    Outer3 :: struct { key: s32; inner: Inner3; }
+    Outer3 :: struct { key: i32; inner: Inner3; }
     out3 := Outer3.{ key = 42, inner = Inner3.{ a = 1.0, b = 2.0, c = 3.0 } };
     ip3 := @out3.inner;
     print("ptr-nested-field: {} {} {}\n", ip3.a, ip3.b, ip3.c);
 
     // Store to many-pointer field must not corrupt adjacent memory
-    MpHolder :: struct { items: [*]s64; sentinel: s64; }
+    MpHolder :: struct { items: [*]i64; sentinel: i64; }
     mph := MpHolder.{ items = xx 0, sentinel = 42 };
     mph.items = xx 0;
     print("mp-store-sentinel: {}\n", mph.sentinel);