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/0900-optionals-optionals.sx

@@ -1,22 +1,22 @@
 #import "modules/std.sx";
 
 // --- Type declarations ---
-OptNode :: struct { value: s32; next: ?s32; }
-OptInner :: struct { val: s32; }
+OptNode :: struct { value: i32; next: ?i32; }
+OptInner :: struct { val: i32; }
 OptOuter :: struct { inner: ?OptInner; }
 
 // --- Comptime optionals ---
-ct_sum :: () -> s32 {
-    x: ?s32 = 42;
-    y: ?s32 = null;
+ct_sum :: () -> i32 {
+    x: ?i32 = 42;
+    y: ?i32 = null;
     return (x ?? 0) + (y ?? 99);
 }
 CT_RESULT :: #run ct_sum();
 
-main :: () -> s32 {
+main :: () -> i32 {
     // Basic optional creation
-    x: ?s32 = 42;
-    y: ?s32 = null;
+    x: ?i32 = 42;
+    y: ?i32 = null;
     print("x = {}\n", x);
     print("y = {}\n", y);
 
@@ -38,7 +38,7 @@ main :: () -> s32 {
     }
 
     // Pattern matching
-    check :: (v: ?s32) -> s32 {
+    check :: (v: ?i32) -> i32 {
         return if v == {
             case .some: (val) { val }
             case .none: { 0 }
@@ -60,14 +60,14 @@ main :: () -> s32 {
     print("o2.inner?.val = {}\n", o2.inner?.val ?? 0);
 
     // Flow-sensitive narrowing
-    a: ?s32 = 10;
-    b: ?s32 = 20;
+    a: ?i32 = 10;
+    b: ?i32 = 20;
     if a != null {
         print("narrowed a: {}\n", a);
     }
 
     // Guard narrowing
-    guard :: (v: ?s32) -> s32 {
+    guard :: (v: ?i32) -> i32 {
         if v == null { return 0; }
         return v;
     }
@@ -80,7 +80,7 @@ main :: () -> s32 {
     }
 
     // Compound guard
-    guard2 :: (a: ?s32, b: ?s32) -> s32 {
+    guard2 :: (a: ?i32, b: ?i32) -> i32 {
         if a == null or b == null { return 0; }
         return a + b;
     }