feat(lang): backtick raw identifier in every binding form + raw-not-a-type + foreign reserved-name fn bare-call [F0.6]

Completes the issue-0089 backtick raw-identifier / `#import c` exemption
across all remaining identifier positions and closes three boundary gaps
the F0.6 review found.

1. Exhaustive raw-binding coverage. The `is_raw` bit now threads through
   `ast.Identifier` and EVERY binding/capture form — `IfExpr`/`WhileExpr`
   optional bindings, `ForExpr` capture + index, `MatchArm` capture,
   `CatchExpr`/`OnFailStmt` tag bindings, `DestructureDecl` per-name, and
   the protocol-default-body / foreign-class method param lists — not just
   `var_decl`/`param`. `UnknownTypeChecker` skips the reserved-name check at
   each arm when raw, so a backtick works in every identifier position while
   a bare reserved spelling still errors (issue 0076 preserved).

2. Raw identifier is never a type. `parseTypeExpr`'s atom rejects a raw
   identifier in type position (`x : `s2 = 1`, `List(`s2)`) with an accurate
   diagnostic instead of silently type-classifying it.

3. Reserved-name function bare-callable. A bare `s2(4)` parses its callee as
   a `.type_expr` (reserved spelling); `lowerCall` now rewrites a type_expr
   callee to an identifier when a function of that name is in scope, so a
   backtick-declared sx fn and a `#import c` foreign fn whose C name collides
   with a reserved type spelling both resolve by their bare name.
   (`TypeName(val)` is not a cast, so there is no ambiguity.)

Tests: examples/0152 (every control-flow/capture form + bare ref/call/member
access), examples/1054 (catch/onfail tag bindings), examples/1139 (raw in
type position rejected), examples/1220 extended (foreign reserved-name
function bare-call). 0076 negatives 1119/1121/1122/1123/1124/1125 stay green.
Gate: zig build + zig build test + 422 examples pass. specs.md + readme.md
updated; issues/0089 RESOLVED banner refreshed.

src/ir/lower.zig

@@ -6621,10 +6621,30 @@ pub const Lowering = struct {
     // ── Calls ───────────────────────────────────────────────────────
 
     fn lowerCall(self: *Lowering, c_in: *const ast.Call) Ref {
+        var c = c_in;
+        // A bare reserved-type-name spelling in call position parses as a
+        // `.type_expr` (e.g. `s2(4)`), but if a function of that name is in
+        // scope — a backtick-declared sx fn or a `#import c` foreign fn whose C
+        // name collides with a reserved type spelling — it is a CALL to that
+        // function. `TypeName(val)` is not a cast (casts are `cast(T, val)`), so
+        // there is no ambiguity. Rewrite the callee to an identifier so the
+        // normal call machinery resolves it, symmetric to the bare-value
+        // reference that already resolves via scope/globals (issue 0089).
+        if (c.callee.data == .type_expr) {
+            const tname = c.callee.data.type_expr.name;
+            const is_fn = self.program_index.fn_ast_map.contains(tname) or
+                (if (self.scope) |scope| scope.lookupFn(tname) != null else false);
+            if (is_fn) {
+                const id_node = self.alloc.create(Node) catch unreachable;
+                id_node.* = .{ .span = c.callee.span, .data = .{ .identifier = .{ .name = tname, .is_raw = true } } };
+                const rewritten = self.alloc.create(ast.Call) catch unreachable;
+                rewritten.* = .{ .callee = id_node, .args = c.args };
+                c = rewritten;
+            }
+        }
         // Expand default parameter values for bare identifier callees:
         // when the caller omits trailing positional args, fill them in
         // from the callee's `param: T = expr` declarations.
-        var c = c_in;
         if (self.expandCallDefaults(c)) |expanded| c = expanded;
         // Check reflection builtins first (before lowering args — some args are type names, not values)
         if (c.callee.data == .identifier) {