fix(ir): infer mixed int+float arithmetic as the promoted float [F0.7]

`ExprTyper.inferType`'s binary-op arm inferred every non-comparison op
from the LHS alone, so `M + 0.5` (s64 + f64) statically typed as s64
while `0.5 + M` typed as f64 — operand-order-dependent. The value path
(`lowerBinaryOp`) already promoted int×float → float, so static
inference disagreed with the value: `M + 0.5` formatted as a truncated
int and a typed const `BAD : s64 : M + 0.5` was accepted+truncated
(issue 0088 mixed-numeric escape).

Extract the value path's inline promotion into a shared
`Lowering.arithResultType(lhs, rhs)` and reuse it at both sites, so
arithmetic / bitwise / shift inference reports exactly the type the
lowered value carries — int LHS × float RHS → the float, order-
independent. The value-path behavior is unchanged (the block is moved
verbatim into the helper), so no IR shifts; the suite stays green. The
typed-const validation reuses `inferExprType`, so this auto-closes the
escape with no change to the validation logic.

- examples/1143: BAD/BAD2 (`s64 : M + 0.5`, `s64 : 0.5 + M`) rejected
  in both operand orders.
- examples/0162: MF/MFR (`f64 : M + 0.5`, `f64 : 0.5 + M`) fold to 2.5.
- examples/0163 (new): pins the inference fix in a value context
  (`print("{}", n + 0.5)` formats the float, both orders, +-*/, f32).
- expr_typer.test.zig: arithResultType + mixed-arithmetic inference.
- specs.md / readme.md: document the numeric-promotion rule.
- issues/0088: RESOLVED banner notes the inferExprType root fix.

src/ir/lower.zig

@@ -3263,19 +3263,12 @@ pub const Lowering = struct {
         const rhs_ref_pointee = self.refCapturePointee(bop.rhs);
         if (rhs_ref_pointee) |p| rhs = self.builder.load(rhs, p);
         self.target_type = saved_tt;
-        // Infer result type from LHS operand (covers float, bool, etc.)
-        var ty = lhs_ty;
-
-        // Promote int×float → float (e.g., s64 * f32 → f32)
-        // Only for scalar int LHS — don't affect vectors or structs.
-        {
-            const rhs_inferred = rhs_ref_pointee orelse self.inferExprType(bop.rhs);
-            const l_int = isInt(ty);
-            const r_float = (rhs_inferred == .f32 or rhs_inferred == .f64);
-            if (l_int and r_float) {
-                ty = rhs_inferred;
-            }
-        }
+        // Result type follows the shared promotion rule: an int LHS with a
+        // float RHS promotes to the float (`s64 * f32` → `f32`); vectors /
+        // structs keep the LHS type. `inferExprType` reuses the same helper
+        // so static typing agrees with the value produced here.
+        const rhs_inferred = rhs_ref_pointee orelse self.inferExprType(bop.rhs);
+        var ty = arithResultType(lhs_ty, rhs_inferred);
 
         // Auto-unwrap optional operands for arithmetic/comparison
         if (!ty.isBuiltin()) {
@@ -14528,6 +14521,20 @@ pub const Lowering = struct {
         return ty == .f32 or ty == .f64;
     }
 
+    /// Result type of an arithmetic / bitwise / shift binary op over two
+    /// scalar operand types. This is the single promotion rule shared by the
+    /// value path (`lowerBinaryOp`) and AST-level inference
+    /// (`ExprTyper.inferType`'s binary-op arm), so static typing reports
+    /// exactly the type the lowered value carries. An integer LHS with a
+    /// floating-point RHS promotes to the float (`s64 + f64` → `f64`); every
+    /// other pairing — including vectors / structs, whose `isInt` is false —
+    /// takes the LHS type. Comparison / logical ops never reach here (they
+    /// are `.bool` at both sites).
+    pub fn arithResultType(lhs_ty: TypeId, rhs_ty: TypeId) TypeId {
+        if (isInt(lhs_ty) and isFloat(rhs_ty)) return rhs_ty;
+        return lhs_ty;
+    }
+
     fn isInt(ty: TypeId) bool {
         return switch (ty) {
             .s8, .s16, .s32, .s64, .u8, .u16, .u32, .u64, .usize, .isize => true,