fix(ir): float / folds as FLOAT division under the unified narrowing rule — int folder refuses a float-operand / [F0.11]

The shared compile-time integer folder (`evalConstIntExpr`) accepts an
integral float literal/const as an integer leaf (`[4.0]` → 4) and then
applied INTEGER arithmetic to the whole expression — so `5.0 / 2.0` folded
as `divTrunc(5,2)` = 2 instead of float division (`2.5`). The bug fired at
all FIVE unified-rule sites (typed local, field default, param default,
typed const, array dimension), because the typed sites evaluate through
`evalConstFloatExpr` (which delegates the node to the int folder) and the
count sites through `foldCountI64` (int folder first).

Fix at the single root: `evalConstIntExpr`'s `.div` arm refuses to fold a
division whose lhs/rhs is float-valued (`isFloatValuedExpr`), so the value
surfaces through `evalConstFloatExpr` + the unified rule — an integral
quotient (`6.0 / 2.0` → 3) folds, a non-integral one (`5.0 / 2.0` = 2.5,
mixed `5 / 2.0`, float-const `F / G`) errors. Genuine integer `/` (`5 / 2`
→ 2) is unchanged; `*`/`+`/`-` need no guard (they agree between int and
float for the integral operands the int folder ever sees).

`isFloatValuedExpr` judges a const-leaf by VALUE (`moduleConstIsFloatTyped`
recurses into the const's value with the existing cycle-guard frame), so an
untyped float-EXPRESSION const (`ME :: 4.0 + 1.0`, placeholder type s64) is
caught at both the count path and — via `foldComptimeFloatInit`'s guard —
the typed-binding path. A backtick RAW receiver (`` `f64.epsilon ``) is a
field read, not a float limit (is_raw check, issues 0092/0093).

Regression: examples/1147 (negative — `5.0 / 2.0` errors at all five sites
plus untyped float-EXPR const div); 0168 extended (positive — `6.0 / 2.0`,
`12.0 / 4.0`, `[6.0/2.0]`, `xx (5.0/2.0)` → 2); unit tests "the int folder
refuses a FLOAT division" and "moduleConstIsFloatTyped judges a const by
VALUE". specs.md + readme.md state the float-`/` rule.

examples/1147-diagnostics-float-division-narrowing.sx

@@ -0,0 +1,46 @@
+// Unified float→int narrowing rule (F0.11), float-DIVISION pin: a compile-time
+// float division (`5.0 / 2.0` = 2.5) is a NON-INTEGRAL float, so narrowing it
+// implicitly into an integer-typed binding is a COMPILE ERROR — exactly like any
+// other non-integral float (example 1146). The division is the subtle case: its
+// operands (`5.0`, `2.0`) are individually INTEGRAL, so a naive integer fold
+// would truncate `5.0 / 2.0` to 2 with no diagnostic. The rule fires at all five
+// sites — a typed module CONST, a struct FIELD default, a function PARAM default,
+// a typed LOCAL, and an array DIMENSION — because the shared compile-time integer
+// folder now refuses a division with a float operand, deferring it to the float
+// evaluator + the unified rule (integral folds, non-integral errors). A float
+// operand on either side (literal or float-typed const) makes the `/` a float
+// division.
+//
+// The escape hatch stays open: `xx (5.0 / 2.0)` truncates to 2 with no error, and
+// an INTEGRAL float division (`6.0 / 2.0` → 3) folds — both exercised on the
+// POSITIVE side (example 0168).
+//
+// Regression (issue 0095, F0.11-6): `5.0 / 2.0` at a typed local, field default,
+// param default, typed const, and array dimension all silently folded to 2 via
+// integer truncating division; each now rejects the non-integral float.
+#import "modules/std.sx";
+
+// An UNTYPED float-EXPRESSION const carries a placeholder `s64` type, yet its
+// value is float — `ME / 2` is still float division and must reject (judged by
+// the const's VALUE, not its declared type), at BOTH the typed-binding path and
+// the count path.
+ME :: 4.0 + 1.0;       // untyped float-EXPRESSION const (= 5.0)
+
+// Typed CONST: declared but not referenced, so the single narrowing error is not
+// followed by a downstream "unresolved const" cascade.
+K : s64 : 5.0 / 2.0;   // 2.5 non-integral float-DIVISION const → error
+
+BadField :: struct {
+    f : s64 = 5.0 / 2.0;   // non-integral float-DIVISION field default → error
+}
+
+badParam :: (x : s64 = 5.0 / 2.0) -> s64 { return x; }  // float-DIVISION param default → error
+
+main :: () {
+    local : s64 = 5.0 / 2.0;     // non-integral float-DIVISION local → error
+    dim : [5.0 / 2.0]s64 = ---;  // non-integral float-DIVISION array dimension → error
+    cdiv : s64 = ME / 2;         // untyped float-EXPR const division (5.0/2 = 2.5) → error
+    cdim : [ME / 2]s64 = ---;    // same, at the count path → error
+    b := BadField.{};
+    print("{} {} {} {} {} {}\n", local, b.f, badParam(), dim.len, cdiv, cdim.len);
+}