fix(lang): numeric-limit intercept no longer shadows raw value bindings [NL.2]

The numeric-limit accessor intercept (NL.1 integer `.min`/`.max`, NL.2 float
`.epsilon`/`.min_positive`/`.true_min`/`.inf`/`.nan`) treated ANY receiver
whose text matched a builtin numeric type name as a TYPE receiver, without
first checking for an in-scope VALUE binding. An F0.6 backtick raw identifier
(`` `f64 := … ``) binds a local under the stripped name `f64`; field access on
it (`` `f64.epsilon ``) parses as an `.identifier` receiver, which the intercept
silently folded to the type's numeric limit — a silent-wrong-value bug
(issue 0092).

Fix: for `.identifier` receivers, prefer an in-scope value binding
(`Scope.lookup`) over the fold — defer to ordinary field lowering when the
identifier resolves to a value. `.type_expr` receivers are unambiguous types
and are never shadowed, so a bare `f64.epsilon`/`s32.max` still folds even in a
scope where `` `f64 `` is bound (the parser classifies a bare builtin name as a
`.type_expr`). Mirrored in expr_typer.zig so inference matches lowering
(avoids the issue-0083 two-resolver desync). Float-only-on-int and
non-numeric-receiver errors are unchanged.

- src/ir/lower.zig: value-binding guard in lowerNumericLimit.
- src/ir/expr_typer.zig: same guard in the numeric-limit inference arm.
- src/ir/expr_typer.test.zig: unit test pinning the two-resolver agreement.
- examples/0161-types-numeric-limit-value-shadow.sx: regression — raw
  `` `f64 ``/`` `s32 ``/`` `u8 `` value reads coexisting with bare folds.
- issues/0092: RESOLVED banner.
- specs.md / readme.md: receiver-vs-shadowing-value-binding note.

src/ir/lower.zig

@@ -4928,6 +4928,19 @@ pub const Lowering = struct {
         };
         if (!TypeResolver.isLimitField(fa.field)) return null;
         const ty = TypeResolver.resolveBuiltinName(name, &self.module.types) orelse return null;
+
+        // A backtick raw identifier (F0.6) can bind a value whose spelling
+        // shadows a builtin type name (`` `f64 := … ``). Field access on that
+        // value is an ordinary field read, not a numeric-limit fold — defer to
+        // the normal field-access path when the receiver identifier resolves to
+        // an in-scope value binding (issue 0092). A `.type_expr` receiver is
+        // unambiguously a type and can never be value-shadowed.
+        if (fa.object.data == .identifier) {
+            if (self.scope) |scope| {
+                if (scope.lookup(name) != null) return null;
+            }
+        }
+
         if (TypeResolver.integerLimitFor(name, fa.field)) |value| {
             return self.builder.constInt(value, ty);
         }