fix(ir): reject typed module const whose initializer mismatches annotation [F0.7]

A typed module-level constant whose initializer did not match its
annotation was silently accepted: `N : string : 4` compiled, then
`print(N)` segfaulted (an integer emitted as a `string` const → a bogus
pointer) and `[N]s64` folded `N` to 4 as an integer count. Issue 0088.

Root cause: `registerTypedModuleConst` stored the annotation type but never
validated the initializer literal against it, and
`program_index.moduleConstInt` folded a const into a count by inspecting
the initializer node alone, ignoring `ModuleConstInfo.ty`.

Fix at the declaration (kills both symptoms):
- lower.zig: `registerTypedModuleConst` now validates the initializer via
  `typedConstInitFits` (arms mirror `emitModuleConst`'s faithful-emit
  precondition: int→int/float, float→float, bool→bool, string→string,
  null→pointer/optional, `---`→any). A mismatch emits a `type mismatch`
  diagnostic at the initializer span and does not register the const (also
  evicting the pass-0 placeholder). Not routed through
  `coercionResolver().classify`: that runtime-coercion planner is unsound
  here (null's natural type is void → false-rejects `*T`; bool is 1 bit →
  false-accepts s64).
- program_index.zig: `moduleConstInt` now takes the `TypeTable` and gates
  the fold on `isCountableConstType(ci.ty)` (integer of any width, or a
  float), so a non-numeric typed const can never fold into a count off its
  initializer node. Callers in lower.zig and type_bridge.zig updated.

Regression:
- examples/1143-diagnostics-typed-module-const-mismatch.sx (negative, exit 1)
- examples/0162-types-typed-module-const-roundtrip.sx (positive)
- program_index.test.zig: gate-on-declared-type unit test

Docs: specs.md §3 Constant Binding + readme.md note the compatibility rule.

src/ir/program_index.zig

@@ -91,20 +91,40 @@ fn moduleConstFrameContains(frame: ?*const ModuleConstFrame, name: []const u8) b
 /// scope, so `lookupPackLen` is always null.
 const ModuleConstCtx = struct {
     consts: *const std.StringHashMap(ModuleConstInfo),
+    table: *const types.TypeTable,
     frame: ?*const ModuleConstFrame,
     pub fn lookupDimName(self: ModuleConstCtx, name: []const u8) ?i64 {
-        return moduleConstIntFramed(self.consts, name, self.frame);
+        return moduleConstIntFramed(self.consts, self.table, name, self.frame);
     }
     pub fn lookupPackLen(_: ModuleConstCtx, _: []const u8) ?i64 {
         return null;
     }
 };
 
-fn moduleConstIntFramed(consts: *const std.StringHashMap(ModuleConstInfo), name: []const u8, parent: ?*const ModuleConstFrame) ?i64 {
+/// A module const may serve as an integer COUNT only when its DECLARED type is
+/// numeric — an integer of any width or a float (an integral float folds to its
+/// int via `floatToIntExact`). `moduleConstIntFramed` consults this so a count
+/// is gated on `ModuleConstInfo.ty`, not just the shape of the initializer node:
+/// a `string`/`bool`/pointer/struct-typed const can never be folded into a count
+/// off an integer-looking initializer (issue 0088 — the second symptom, where
+/// `N : string : 4` folded `[N]s64` to 4 by reading the `int_literal` node and
+/// ignoring the `string` annotation).
+fn isCountableConstType(table: *const types.TypeTable, ty: TypeId) bool {
+    return switch (ty) {
+        .s8, .s16, .s32, .s64, .u8, .u16, .u32, .u64, .usize, .isize, .f32, .f64 => true,
+        else => if (ty.isBuiltin()) false else switch (table.get(ty)) {
+            .signed, .unsigned => true,
+            else => false,
+        },
+    };
+}
+
+fn moduleConstIntFramed(consts: *const std.StringHashMap(ModuleConstInfo), table: *const types.TypeTable, name: []const u8, parent: ?*const ModuleConstFrame) ?i64 {
     if (moduleConstFrameContains(parent, name)) return null;
     const ci = consts.get(name) orelse return null;
+    if (!isCountableConstType(table, ci.ty)) return null;
     var frame = ModuleConstFrame{ .name = name, .parent = parent };
-    return evalConstIntExpr(ci.value, ModuleConstCtx{ .consts = consts, .frame = &frame });
+    return evalConstIntExpr(ci.value, ModuleConstCtx{ .consts = consts, .table = table, .frame = &frame });
 }
 
 /// A name bound to a module-global integer constant → its value, else null.
@@ -120,8 +140,8 @@ fn moduleConstIntFramed(consts: *const std.StringHashMap(ModuleConstInfo), name:
 /// RHS over other consts (`M :: 2; N :: M + 1` → 3) all resolve identically and
 /// everywhere a count is accepted. Cyclic consts fold to null (see
 /// `ModuleConstCtx`).
-pub fn moduleConstInt(consts: *const std.StringHashMap(ModuleConstInfo), name: []const u8) ?i64 {
-    return moduleConstIntFramed(consts, name, null);
+pub fn moduleConstInt(consts: *const std.StringHashMap(ModuleConstInfo), table: *const types.TypeTable, name: []const u8) ?i64 {
+    return moduleConstIntFramed(consts, table, name, null);
 }
 
 /// Evaluate a constant integer expression to its value. THE single