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/0019-basic-dot-shorthand.sx

@@ -24,7 +24,7 @@ Vec2 :: struct {
     unit_x :: () -> Vec2 { Vec2.{ x = 1.0, y = 0.0 } }
     add :: (a: Vec2, b: Vec2) -> Vec2 { Vec2.{ x = a.x + b.x, y = a.y + b.y } }
     scale :: (v: Vec2, s: f32) -> Vec2 { Vec2.{ x = v.x * s, y = v.y * s } }
-    len :: (v: Vec2) -> s32 { xx (v.x + v.y) }
+    len :: (v: Vec2) -> i32 { xx (v.x + v.y) }
 }
 
 EdgeInsets :: struct {
@@ -39,16 +39,16 @@ EdgeInsets :: struct {
 }
 
 Trio :: struct {
-    a: s32;
-    b: s32;
-    c: s32;
+    a: i32;
+    b: i32;
+    c: i32;
 
-    make :: (a: s32, b: s32, c: s32) -> Trio { Trio.{ a = a, b = b, c = c } }
-    sum :: (t: Trio) -> s32 { t.a + t.b + t.c }
+    make :: (a: i32, b: i32, c: i32) -> Trio { Trio.{ a = a, b = b, c = c } }
+    sum :: (t: Trio) -> i32 { t.a + t.b + t.c }
 }
 
 Result :: enum {
-    ok: s32;
+    ok: i32;
     err: string;
 }
 
@@ -121,7 +121,7 @@ main :: () {
 
     // T8: .variant(payload) as function argument (match-as-expression)
     {
-        describe :: (sh: Shape) -> s32 {
+        describe :: (sh: Shape) -> i32 {
             if sh == {
                 case .circle: 10;
                 case .rect: 20;
@@ -145,7 +145,7 @@ main :: () {
 
     // T10: Match as expression returning tagged enum
     {
-        select :: (n: s32) -> Shape {
+        select :: (n: i32) -> Shape {
             if n == {
                 case 0: .none;
                 case 1: .circle(1.0);
@@ -243,7 +243,7 @@ main :: () {
     // E2: Function taking both types — each resolves correctly
     {
         use_both :: (sh: Shape, v: Vec2) {
-            ms : s32 = 0;
+            ms : i32 = 0;
             if sh == { case .circle: (r) { ms = xx r; } else: {} }
             print("E2: {} {} {}\n", ms, v.x, v.y);
         }
@@ -252,7 +252,7 @@ main :: () {
 
     // E3: Bare .variant (no parens) as function arg
     {
-        check_none :: (sh: Shape) -> s32 {
+        check_none :: (sh: Shape) -> i32 {
             if sh == { case .none: 1; else: 0; }
         }
         print("E3: {}\n", check_none(.none));
@@ -268,7 +268,7 @@ main :: () {
     // E5: Tagged enum .variant(payload) in match-as-expression
     {
         sh : Shape = .circle(42.0);
-        r : s32 = 0;
+        r : i32 = 0;
         if sh == {
             case .circle: (v) { r = xx v; }
             case .rect: (sz) { r = xx sz.w; }
@@ -280,7 +280,7 @@ main :: () {
     // E6: Color enum (plain, not tagged) still works with bare .variant
     {
         c : Color = .green;
-        ci : s32 = xx c;
+        ci : i32 = xx c;
         print("E6: {}\n", ci);
     }