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).

specs.md

@@ -1426,14 +1426,19 @@ isReady : ValueListenable(bool) = map(
 an integer-typed binding without `xx`/`cast` is governed by the SAME rule an
 array dimension / lane count uses (see "Array dimensions are integral", §2):
 
-- An **integral** compile-time float **folds** to its integer:
-  `y : s64 = 4.0` ≡ `y : s64 = 4`, `n : s64 = -2.0` ≡ `-2`.
-- A **non-integral** compile-time float is a **compile error**:
-  `y : s64 = 1.5` → "cannot implicitly narrow non-integral float '1.5' to 's64'".
+- An **integral** compile-time float **folds** to its integer, whether written
+  as a literal or a const expression: `y : s64 = 4.0` ≡ `y : s64 = 4`,
+  `n : s64 = -2.0` ≡ `-2`, `y : s64 = M + 2.0` → 4 (`M :: 2`).
+- A **non-integral** compile-time float — literal OR const expression — is a
+  **compile error** with one uniform wording at every site:
+  `y : s64 = 1.5` and `y : s64 = M + 0.5` both →
+  "cannot implicitly narrow non-integral float '…' to 's64'; use an explicit
+  cast (`xx`/`cast`)".
 - This applies uniformly to a typed **local**, a function **param default**, a
-  struct **field default**, and a typed module **constant**
-  (`K : s64 : 4.0` → 4; `N : s64 : 1.5` → error; `K : s64 : M + 2.0` → 4 when
-  the expression folds to an integer).
+  struct **field default**, a call **argument**, and a typed module **constant**
+  (`K : s64 : 4.0` → 4; `K : s64 : M + 2.0` → 4; `N : s64 : 1.5` and
+  `N : s64 : M + 0.5` → error). A **runtime** float (one with no compile-time
+  value) is unaffected — narrow it explicitly with `xx`/`cast`.
 
 **Explicit (narrowing)** — requires `xx` prefix (or `cast(T)`):
 - Integer to narrower integer (`s32` → `u8`)