fix(ir): unify float→int narrowing — integral folds, non-integral errors [F0.11]

Issue 0095: a typed local/param/field silently TRUNCATED a float initializer
to an integer annotation (`y : s64 = 1.5` → 1) with no diagnostic. Agra ruled
the UNIFIED rule (Option B): an implicit float→int in a typed binding behaves
like the array-dimension rule —

  - an INTEGRAL compile-time float FOLDS to its int (`4.0` → 4, `-2.0` → -2);
  - a NON-integral float is a COMPILE ERROR (`1.5`, `4.5`);
  - explicit `xx` / `cast(T)` ALWAYS truncates (the escape hatch).

Applied consistently to typed local / param-default / field-default, typed
module CONST, and array dim — all reusing the single
`program_index.floatToIntExact` / `evalConstIntExpr` facility (no second
integral check).

- `Builder.constFloatInfo` reads a compile-time `const_float` back from its
  Ref (value + span).
- `coerceToType` is now the IMPLICIT path: its `.float_to_int` arm folds an
  integral const-float to `constInt`, else emits the narrowing diagnostic.
  `coerceExplicit` is the raw truncating path; `xx` (lowerXX) and `cast(T)`
  route through it so the escape still truncates.
- Field-default lowering (struct-literal pad, named-field default,
  buildDefaultValue) now coerces the default to the field type at the IR level
  (was silently bit-coerced by emitStructInit).
- Const path: `typedConstInitFits` accepts an integral float (literal or a
  `M + 2.0`-style expression folding via `evalComptimeInt`); `emitModuleConst`
  / `constExprValue` / `globalInitValue` fold an integral float to its int and
  reject a non-integral one — relaxing F0.7's blanket float rejection.

Tests: examples/0168 (positive: local/field/param/const fold, xx/cast
truncate), examples/1146 (negative: local/param/field error), integral-float
const cases added to examples/0162; non-integral const cases in 1143 stay
errors. specs.md + readme.md document the unified rule, cross-referencing the
array-dim rule. issues/0095 marked RESOLVED.

src/ir/module.test.zig

@@ -114,3 +114,28 @@ test "Module: globals" {
     try std.testing.expectEqual(GlobalId.fromIndex(0), id);
     try std.testing.expectEqual(TypeId.s32, mod.globals.items[0].ty);
 }
+
+test "Builder.constFloatInfo reads a const_float back, null for non-floats" {
+    const alloc = std.testing.allocator;
+    var mod = Module.init(alloc);
+    defer mod.deinit();
+
+    var b = Builder.init(&mod);
+    const name = mod.types.internString("f");
+    const entry_name = mod.types.internString("entry");
+    _ = b.beginFunction(name, &.{}, .void);
+    const entry = b.appendBlock(entry_name, &.{});
+    b.switchToBlock(entry);
+
+    // A const_float reads back its value (the implicit float→int rule consults
+    // this to fold an integral literal / locate a non-integral one).
+    const fref = b.constFloat(4.0, .f64);
+    const info = b.constFloatInfo(fref) orelse return error.TestUnexpectedResult;
+    try std.testing.expectEqual(@as(f64, 4.0), info.value);
+
+    // A non-float instruction is not a const_float — null.
+    const iref = b.constInt(7, .s64);
+    try std.testing.expect(b.constFloatInfo(iref) == null);
+
+    b.finalize();
+}