fix(std): render integer formatter extremes — i64::MIN and unsigned all-ones [F0.8]

Resolves issue 0090. The `{}` integer formatter mis-rendered both ends of
the 64-bit range:

- `int_to_string` computed the magnitude as `0 - n`, which overflows for
  `s64::MIN` (its magnitude is unrepresentable as a positive s64) — the
  value stayed negative, the digit loop ran zero times, so only `-`
  printed. It now extracts digits straight from `n` (per-digit
  `|n % 10|`, `n` truncating toward zero), never negating MIN.

- `any_to_string`'s `case int:` formatted every integer as s64, so a u64
  all-ones value printed as `-1`. There was no `uint` type-category to
  distinguish signedness. Added an additive `type_is_unsigned(T)`
  reflection builtin (static fold + dynamic interp/LLVM paths, mirroring
  `type_name`), backed by the new `TypeTable.isUnsignedInt` predicate, and
  a `uint_to_string` formatter (unsigned decimal via long-division over
  four 16-bit limbs). `case int:` routes through `type_is_unsigned(type)`.

The 16-bit-limb split is factored into a shared `decompose_u16x4`, now
reused by `int_to_hex_string` (no second unsigned-math routine).

Regression: examples/0046-basic-int-formatter-extremes pins both extremes
plus a width spread; unit tests cover `isUnsignedInt`. Docs (specs.md
representation note, readme std API) updated for unsigned/extreme `{}`
behavior. IR snapshots refreshed for the two new std functions.

src/ir/types.zig

@@ -580,6 +580,20 @@ pub const TypeTable = struct {
         return 8;
     }
 
+    /// True iff `ty` is an unsigned integer — a builtin (u8/u16/u32/u64/usize)
+    /// or a user-defined arbitrary-width unsigned int. Canonical signedness
+    /// query for reflection (`type_is_unsigned`) and the `{}` formatter so a
+    /// u64 value renders as unsigned decimal rather than the s64 reinterpretation.
+    pub fn isUnsignedInt(self: *const TypeTable, ty: TypeId) bool {
+        switch (ty) {
+            .u8, .u16, .u32, .u64, .usize => return true,
+            .bool, .s8, .s16, .s32, .s64, .isize => return false,
+            else => {},
+        }
+        if (ty.isBuiltin()) return false;
+        return self.get(ty) == .unsigned;
+    }
+
     pub fn typeSizeBytes(self: *const TypeTable, ty: TypeId) usize {
         const ptr_size: usize = self.pointer_size;
         if (ty == .void) return 0;