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/0168-types-integral-float-to-int.sx

@@ -30,6 +30,7 @@ Box :: struct {
     n  : s64 = 4.0;       // integral float field default → folds to 4
     ne : s64 = M + 2.0;   // integral int-const-EXPR field default → folds to 4
     nf : s64 = F + 1.5;   // integral float-const-LEAF field default → folds to 4
+    nd : s64 = 8.0 / 2.0; // integral float-DIVISION field default → folds to 4
 }
 
 withDefault :: (x : s64 = 6.0)     -> s64 { return x; }   // param default → 6
@@ -37,6 +38,7 @@ withFlt     :: (x : s64 = F + 1.5) -> s64 { return x; }   // float-const-leaf pa
 
 K  : s64 : 8.0;          // integral float module const → folds to 8
 KF : s64 : F + 1.5;      // integral float-const-LEAF module const → folds to 4
+KD : s64 : 12.0 / 4.0;   // integral float-DIVISION module const → folds to 3
 
 ArrFE :: [F + 1.5]s64;   // array-dim type ALIAS over a float-const-leaf expr → [4]s64
                          // (the stateless registration path must agree with the
@@ -53,9 +55,16 @@ main :: () {
     neg : s64 = -2.0;
     print("neg={}\n", neg);
 
-    // Struct field defaults fold (literal + int-const expr + float-const leaf).
+    // Integral float DIVISION folds (the subtle case: integral operands, but the
+    // `/` is float division). `6.0 / 2.0` = 3.0 → 3; the int folder refuses the
+    // float `/` and the unified rule folds the integral result.
+    zd : s64 = 6.0 / 2.0;
+    print("localDiv={}\n", zd);
+
+    // Struct field defaults fold (literal + int-const expr + float-const leaf +
+    // float division).
     b := Box.{};
-    print("field={} fieldExpr={} fieldFlt={}\n", b.n, b.ne, b.nf);
+    print("field={} fieldExpr={} fieldFlt={} fieldDiv={}\n", b.n, b.ne, b.nf, b.nd);
 
     // Param defaults fold.
     print("param={} paramFlt={}\n", withDefault(), withFlt());
@@ -64,6 +73,11 @@ main :: () {
     a : [K]s64 = ---;
     print("const={} constFlt={} len={}\n", K, KF, a.len);
 
+    // Integral float-DIVISION const folds, and drives an array dimension directly
+    // (`[6.0 / 2.0]` → len 3) through the SAME refuse-int-fold / fold-float rule.
+    ad2 : [6.0 / 2.0]s64 = ---;
+    print("constDiv={} dimDiv={}\n", KD, ad2.len);
+
     // Array DIMENSION — the fifth site joins the unified rule: an integral
     // float-const-leaf expression folds to a count whether written DIRECTLY
     // (`[F + 1.5]` → 4), THROUGH a float-expr const (`[KF]`, KF = F + 1.5 = 4),
@@ -100,5 +114,6 @@ main :: () {
     xf : s64 = xx (F + 0.25);
     xl : s64 = xx (f64.true_min + 0.5);
     xm : s64 = xx (5.5 % 2.0);
-    print("xx={} cast={} xxExpr={} xxFlt={} xxLimit={} xxMod={}\n", e, c, xc, xf, xl, xm);
+    xd : s64 = xx (5.0 / 2.0);   // non-integral float DIVISION → truncates to 2
+    print("xx={} cast={} xxExpr={} xxFlt={} xxLimit={} xxMod={} xxDiv={}\n", e, c, xc, xf, xl, xm, xd);
 }

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);
+}

examples/expected/0168-types-integral-float-to-int.stdout

@@ -1,9 +1,11 @@
 local=4 localExpr=4 localFlt=4
 neg=-2
-field=4 fieldExpr=4 fieldFlt=4
+localDiv=3
+field=4 fieldExpr=4 fieldFlt=4 fieldDiv=4
 param=6 paramFlt=4
 const=8 constFlt=4 len=8
+constDiv=3 dimDiv=3
 dim.direct=4 dim.const=4 dim.alias=4
 limit=0 fmod=2
 intlimit=127 intcount=255
-xx=4 cast=1 xxExpr=2 xxFlt=2 xxLimit=0 xxMod=1
+xx=4 cast=1 xxExpr=2 xxFlt=2 xxLimit=0 xxMod=1 xxDiv=2

examples/expected/1147-diagnostics-float-division-narrowing.exit

@@ -0,0 +1 @@
+1

examples/expected/1147-diagnostics-float-division-narrowing.stderr

@@ -0,0 +1,41 @@
+error: cannot implicitly narrow non-integral float '2.5' to 's64'; use an explicit cast (`xx`/`cast`)
+  --> examples/1147-diagnostics-float-division-narrowing.sx:31:11
+   |
+31 | K : s64 : 5.0 / 2.0;   // 2.5 non-integral float-DIVISION const → error
+   |           ^^^^^^^^^
+
+error: cannot implicitly narrow non-integral float '2.5' to 's64'; use an explicit cast (`xx`/`cast`)
+  --> examples/1147-diagnostics-float-division-narrowing.sx:40:19
+   |
+40 |     local : s64 = 5.0 / 2.0;     // non-integral float-DIVISION local → error
+   |                   ^^^^^^^^^
+
+error: array dimension must be an integer, but '2.5' is a non-integral float
+  --> examples/1147-diagnostics-float-division-narrowing.sx:41:12
+   |
+41 |     dim : [5.0 / 2.0]s64 = ---;  // non-integral float-DIVISION array dimension → error
+   |            ^^^^^^^^^
+
+error: cannot implicitly narrow non-integral float '2.5' to 's64'; use an explicit cast (`xx`/`cast`)
+  --> examples/1147-diagnostics-float-division-narrowing.sx:42:18
+   |
+42 |     cdiv : s64 = ME / 2;         // untyped float-EXPR const division (5.0/2 = 2.5) → error
+   |                  ^^^^^^
+
+error: array dimension must be an integer, but '2.5' is a non-integral float
+  --> examples/1147-diagnostics-float-division-narrowing.sx:43:13
+   |
+43 |     cdim : [ME / 2]s64 = ---;    // same, at the count path → error
+   |             ^^^^^^
+
+error: cannot implicitly narrow non-integral float '2.5' to 's64'; use an explicit cast (`xx`/`cast`)
+  --> examples/1147-diagnostics-float-division-narrowing.sx:34:15
+   |
+34 |     f : s64 = 5.0 / 2.0;   // non-integral float-DIVISION field default → error
+   |               ^^^^^^^^^
+
+error: cannot implicitly narrow non-integral float '2.5' to 's64'; use an explicit cast (`xx`/`cast`)
+  --> examples/1147-diagnostics-float-division-narrowing.sx:37:24
+   |
+37 | badParam :: (x : s64 = 5.0 / 2.0) -> s64 { return x; }  // float-DIVISION param default → error
+   |                        ^^^^^^^^^