fix(ir): evalConstFloatExpr reaches parity with evalConstIntExpr — numeric-limit float leaves + float % fold under the unified rule [F0.11]

The compile-time float evaluator lagged the integer one: it had no
numeric-limit field-access arm, so `y : s64 = f64.true_min + 0.5` (=0.5)
silently truncated to 0 even though the direct `f64.true_min` already
errored; the arm-by-arm audit also found a missing `%` arm, so
`y : s64 = 5.5 % 2.0` (=1.5) silently truncated to 1.

Bring evalConstFloatExpr to PARITY with evalConstIntExpr:
- Add a `.field_access` arm resolving a builtin FLOAT numeric-limit
  accessor (`f64.max`, `f32.epsilon`, `f64.true_min`, …) via the SAME
  `type_resolver.floatLimitFor` that `lowerNumericLimit` uses — the float
  twin of the int evaluator's `integerLimitFor` arm.
- Add a `.mod` arm via `@rem` (matching evalConstIntExpr and codegen's
  `frem`): `6.0 % 4.0` folds to 2 (via int delegation), `5.5 % 2.0` = 1.5
  is rejected.

The two evaluators now share every leaf/operator shape, so no
compile-time-const float form escapes the unified float→int rule at one
site while folding at another. All five sites (local/field/param/const/
array-dim) stay consistent.

Regression: 0168 (positive) adds `f64.max - f64.max` → 0, `6.0 % 4.0` → 2,
integer-limit `s8.max`/`[u8.max]` unregressed, `xx` escapes for both new
forms; 1146 (negative) adds `f64.true_min + 0.5` and `5.5 % 2.0` erroring
at a binding site; program_index.test.zig covers the floatLimitFor arm and
the `%` arm. specs.md + readme.md state the parity. issues/0095 RESOLVED
banner gains the attempt-5 entry.

examples/1146-diagnostics-nonintegral-float-to-int.sx

@@ -4,13 +4,17 @@
 // PARAM default, a struct FIELD default, AND an array DIMENSION; each emits a
 // narrowing diagnostic at the offending float and aborts (exit 1). It fires
 // whether the float is a LITERAL (`1.5`), an INT-const-expression (`M + 0.5`,
-// with `M :: 2`), or a FLOAT-const-leaf expression (`F + 0.25`, with
-// `F : f64 : 2.5`, = 2.75) — all three are the core of issue 0095, which
-// previously slipped through and truncated to 2. The fix is the integral-fold /
-// non-integral-error rule shared across all five sites (local, field, param,
-// const, and array dimension), applied to ANY compile-time-constant float
-// expression (literal, int-const leaf, float-const leaf, and combinations). The
-// array-dimension site phrases the same rejection as "must be an integer".
+// with `M :: 2`), a FLOAT-const-leaf expression (`F + 0.25`, with `F : f64 : 2.5`,
+// = 2.75), a builtin FLOAT numeric-limit leaf inside an expression
+// (`f64.true_min + 0.5` = 0.5), or a float `%` whose remainder is non-integral
+// (`5.5 % 2.0` = 1.5) — all of these are the core of issue 0095, which previously
+// slipped through and truncated. The fix is the integral-fold / non-integral-error
+// rule shared across all five sites (local, field, param, const, and array
+// dimension), applied to ANY compile-time-constant float expression (literal,
+// int-const leaf, float-const leaf, numeric-limit leaf, `+ - * / %`, and
+// combinations) — the compile-time float evaluator is at parity with the integer
+// one, so no float leaf shape escapes. The array-dimension site phrases the same
+// rejection as "must be an integer".
 //
 // The escape hatch stays open: `y : s64 = xx 1.5` (or `cast(s64) 1.5`)
 // truncates with no error — exercised on the POSITIVE side (example 0168).
@@ -36,9 +40,11 @@ main :: () {
     y  : s64 = 1.5;       // non-integral float LITERAL local → error
     ye : s64 = M + 0.5;   // non-integral int-const-EXPRESSION local → error
     yf : s64 = F + 0.25;  // non-integral float-const-LEAF local → error
+    yn : s64 = f64.true_min + 0.5;  // non-integral numeric-limit float expr → error
+    ym : s64 = 5.5 % 2.0;           // non-integral float `%` remainder (1.5) → error
     ad : [F + 0.25]s64 = ---;  // non-integral float-const-LEAF array DIMENSION → error
     b := Bad.{};
     print("{} {} {}\n", b.f, b.fe, b.ff);
     print("{} {} {}\n", badLit(), badExpr(), badFlt());
-    print("{} {} {} {}\n", y, ye, yf, ad.len);
+    print("{} {} {} {} {} {}\n", y, ye, yf, yn, ym, ad.len);
 }