fix(ir): array-dim/count path joins the unified float→int rule — all 5 sites consistent [F0.11]

The compile-time count fold (array dimension / Vector lane / value-param) was
integer-only: it folded a DIRECT integral float literal (`[4.0]`, `[N]` with
`N : f64 : 4.0`) but rejected an INTEGRAL expression built from a non-integral
float-const leaf (`[F + 1.5]` = 4.0, `F : f64 : 2.5`) — and a const folded from
one (`[K]` with `K : s64 : F + 1.5`) — as "must be a compile-time integer
constant". This was the last of issue 0095's five narrowing sites (local /
field / param / const / array-dim) still diverging.

Route the count fold through the SAME compile-time float evaluation the other
four sites use:

- New `program_index.foldCountI64` — the single int-or-integral-float count
  fold: `evalConstIntExpr` first, then (only on failure) `evalConstFloatExpr` +
  `floatToIntExact`. `foldDimU32` (dim/lane/u32 value-param), the non-u32
  value-param gate, and `emitModuleConst`'s integer-const materialization all
  delegate to it, so a const's emitted value and its use as a count come from
  one fold (no parallel integral check, no two-resolver divergence — issue 0083).
- New `DimU32.non_integral_float` variant carries a non-integral float dim to a
  distinct, accurate diagnostic ("array dimension must be an integer, but '2.75'
  is a non-integral float") — the cast-escape advice the binding sites give does
  not apply in a count position, so the dim wording omits it. `reportDimError`,
  the Vector-lane resolver, and the top-level array-alias diagnostic all handle
  the new variant, so the DIRECT and type-ALIAS forms emit the identical message.
- `type_bridge.StatelessInner.lookupFloatName` (via `moduleConstFloat`) is the
  float twin of its `lookupDimName`, so the registration-time alias path folds a
  float-const-leaf dimension to the SAME count as the stateful direct path.

`inline for` range bounds are spec endpoints, not counts (specs.md §2), so they
keep the int-only fold deliberately (no silent-truncation bug there).

Relaxes the F0.4 `examples/1132` wording: a non-integral float const dim now
reports the precise "non-integral float" message (it still errors).

Regression: 0168 (positive — `[F + 1.5]s64`, `[KF]s64`, alias `ArrFE` all fold
to len 4), 1146 (negative — `[F + 0.25]s64` errors), 1132 (precise wording), and
a `foldCountI64`/`foldDimU32` unit test. issues/0095 marked RESOLVED (attempt 4).
specs.md + readme.md state the unified rule across all five sites.

src/ir/program_index.test.zig

@@ -378,3 +378,39 @@ test "evalConstFloatExpr folds comptime float expressions, halts on runtime leav
     try std.testing.expect(eval(&cmp, ctx) == null);
     try std.testing.expect(eval(&divz, ctx) == null);
 }
+
+test "foldCountI64 / foldDimU32 fold an integral float count, reject a non-integral one" {
+    const ctx = DimCtx{}; // M = 4, F = 2.5 (non-integral float const)
+
+    var five = nLit(5);
+    var f4 = nFloat(4.0);
+    var f45 = nFloat(4.5);
+    var f = nIdent("F");
+    var quarter = nFloat(0.25);
+    var three_half = nFloat(1.5);
+    var fh = nBin(.add, &f, &three_half); // F + 1.5 = 4.0  (integral)
+    var fq = nBin(.add, &f, &quarter); //    F + 0.25 = 2.75 (non-integral)
+    var z = nIdent("Z"); // unbound — genuinely non-const
+
+    // foldCountI64: integer / integral-float (literal OR float-const-leaf SUM)
+    // fold to `.int`; a non-integral compile-time float surfaces as
+    // `.non_integral`; a runtime leaf is `.not_const`.
+    try std.testing.expectEqual(pi.CountFold{ .int = 5 }, pi.foldCountI64(&five, ctx));
+    try std.testing.expectEqual(pi.CountFold{ .int = 4 }, pi.foldCountI64(&f4, ctx));
+    try std.testing.expectEqual(pi.CountFold{ .int = 4 }, pi.foldCountI64(&fh, ctx));
+    try std.testing.expectEqual(pi.CountFold{ .non_integral = 2.75 }, pi.foldCountI64(&fq, ctx));
+    try std.testing.expectEqual(pi.CountFold.not_const, pi.foldCountI64(&z, ctx));
+
+    // foldDimU32 (min 0) inherits the rule: an integral float-const-leaf dim
+    // narrows to a `u32` count, a non-integral one reports `.non_integral_float`,
+    // a runtime one `.not_const`.
+    try std.testing.expectEqual(pi.DimU32{ .ok = 4 }, pi.foldDimU32(&fh, ctx, 0));
+    try std.testing.expectEqual(pi.DimU32{ .non_integral_float = 2.75 }, pi.foldDimU32(&fq, ctx, 0));
+    try std.testing.expectEqual(pi.DimU32{ .non_integral_float = 4.5 }, pi.foldDimU32(&f45, ctx, 0));
+    try std.testing.expectEqual(pi.DimU32.not_const, pi.foldDimU32(&z, ctx, 0));
+
+    // A NEGATIVE integral float folds to its integer first, then the u32 gate
+    // rejects it as below-minimum — NOT as a non-integral float (it IS integral).
+    var negf = nNeg(&f4); // -4.0 → -4
+    try std.testing.expectEqual(pi.DimU32{ .below_min = -4 }, pi.foldDimU32(&negf, ctx, 0));
+}