fix(ir): narrow non-integral const-float EXPRESSIONS at typed local/field/param; align const message [F0.11]

Completes issue 0095 (attempt 2). The attempt-1 coerce arm only caught a direct
`const_float` literal, so a non-integral const-folded float EXPRESSION still
truncated silently at a typed local / field default / param default:

  M :: 2;
  local : s64 = M + 0.5;   // → 2  (silent truncation — BUG; now ERRORS)
  fld   : s64 = M + 0.5;   // field default — same
  take(x : s64 = M + 0.5)  // param default — same

while the typed-CONST site already errored. The integral expression
(`M + 2.0` → 4) folded but the runtime/explicit-cast paths must stay untouched.

Fix:
- New `program_index.evalConstFloatExpr` — the f64 counterpart to
  `evalConstIntExpr`, delegating every integer subtree back to it (no parallel
  integer logic) and adding only the float literal / unary-negate / `+ - * /`
  arms. Pure (no diagnostics, no resolution side effects).
- `Lowering.foldComptimeFloatInit` applies the unified rule to a typed-binding
  initializer EXPRESSION: an integral comptime float folds to its `constInt`, a
  non-integral one errors, a genuine runtime float / `xx`-cast falls through to
  the normal path. It runs `evalConstFloatExpr` FIRST (pure) so a `$pack[i]`
  argument is never spuriously type-resolved outside an active binding, then
  gates on `isFloat(inferExprType)` so a plain comptime int is left alone.
  Wired into the typed-local path, the three struct field-default sites (via a
  shared `lowerCoercedDefault`), and the call-argument loop (covers expanded
  param defaults).
- One `Lowering.diagNonIntegralNarrow` now emits the narrowing wording at all
  five sites (coerce arm, global init, const-expr value, the typed-binding
  sites, and the typed-const path). The typed-CONST non-integral diagnostic
  therefore reads "cannot implicitly narrow non-integral float …" instead of
  the stale "initializer is a float literal / floating-point expression".

Tests: examples/1146 (negative) extended with non-integral const-EXPRESSION
cases at local/field/param; examples/0168 (positive) extended with integral
const-EXPRESSION folds and `xx (M + 0.5)` truncation; examples/1143 reconciled
to the aligned const message (G/BAD/BAD2 stay errors); unit test
`evalConstFloatExpr folds comptime float expressions`. Full gate green (447).

src/ir/program_index.zig

@@ -218,6 +218,48 @@ pub fn evalConstIntExpr(node: *const Node, ctx: anytype) ?i64 {
     };
 }
 
+/// Compile-time FLOAT value of a numeric expression, or null when it is not a
+/// compile-time constant (some leaf is a runtime value) or is not a numeric
+/// shape. THE float counterpart to `evalConstIntExpr`, used by the unified
+/// float→int narrowing rule to (1) tell a compile-time float initializer apart
+/// from a runtime one and (2) recover its value for `floatToIntExact` (integral
+/// → fold) / the non-integral diagnostic.
+///
+/// An all-integer-foldable subtree is delegated to `evalConstIntExpr` (so module
+/// / comptime consts, `<IntType>.min`/`.max`, and integer arithmetic resolve
+/// through the SINGLE int folder — no parallel integer logic here); only the
+/// genuinely float-producing shapes — a float literal, a unary negate, and
+/// `+ - * /` arithmetic involving a float — are evaluated here in `f64`. A `%`,
+/// comparison, or any other shape is not a compile-time float leaf → null.
+pub fn evalConstFloatExpr(node: *const Node, ctx: anytype) ?f64 {
+    // Delegate any integer-foldable subtree (incl. an INTEGRAL float like `4.0`
+    // / `M + 2.0`) to the single int folder, then promote — keeps named consts
+    // and `.min`/`.max` resolution in one place.
+    if (evalConstIntExpr(node, ctx)) |iv| return @floatFromInt(iv);
+    return switch (node.data) {
+        .float_literal => |lit| lit.value,
+        .unary_op => |u| switch (u.op) {
+            .negate => {
+                const v = evalConstFloatExpr(u.operand, ctx) orelse return null;
+                return -v;
+            },
+            else => null,
+        },
+        .binary_op => |b| {
+            const l = evalConstFloatExpr(b.lhs, ctx) orelse return null;
+            const r = evalConstFloatExpr(b.rhs, ctx) orelse return null;
+            return switch (b.op) {
+                .add => l + r,
+                .sub => l - r,
+                .mul => l * r,
+                .div => if (r == 0.0) null else l / r,
+                else => null,
+            };
+        },
+        else => null,
+    };
+}
+
 /// The outcome of folding a comptime-int and narrowing it to a `u32` count
 /// (array dimension / Vector lane / value-param count). `foldDimU32` is the
 /// SINGLE place a folded integer becomes a `u32`, so the i64→u32 narrowing is