feat(check): catch block narrows target to error

Inside an assignment's catch block, reads of the assignment target
now see type `error` rather than the post-success type the frame
held coming out of walkAssign.

The runtime guarantee is clear: a catch block executes precisely
because the RHS errored - so within the catch body, the target IS
carrying an error value. Previously the catch body walked under the
frame walkAssign set up for the success path (the assignment target
narrowed to the RHS value type), which silently said "the user
referenced x inside the catch, and x is int" - incorrect, since the
RHS errored on this path.

The override is the error arm of the RHS type when extractable:
parse_int returns int|error, so the override is `error` (the second
arm). Falls back to a bare TypingErrorT when no error arm is
visible (we couldn't introspect the RHS type, but the runtime
already guarantees we're in the error branch - error is sound).

After the catch body, tc.frame is restored. The catch's body
narrowing doesn't leak into subsequent statements - exactly what
the immutable frame's save/restore pattern gives us.

extractErrorFrom lives next to stripErrorFrom in narrow.go (they're
duals - one returns the error component, the other returns
everything except). Shared code: future error-path narrowings
(e.g. ExprStmt + catch in shell statements) can reuse the same
helper.

Author: amterp

rts/check/snapshots/narrow/catch.snap

@@ -0,0 +1,48 @@
+### TITLE ###
+CatchBlockNarrowsTargetToError
+### DESCRIPTION ###
+Inside an assignment's catch block, the target carries the error
+value the catch fired on. Reads of x within the catch body see
+type `error`; reads after the catch see the (potentially still
+error-typed) RHS result.
+### INPUT ###
+x = parse_int("foo") catch:
+    print(x)
+    yield 0
+y = x
+### STDOUT ###
+# Identifier types
+  x @ 1:1 -> <no-type>
+  parse_int @ 1:5 -> dynamic
+  print @ 2:5 -> dynamic
+  x @ 2:11 -> error
+  y @ 4:1 -> <no-type>
+  x @ 4:5 -> int|error
+
+# Symbol types
+  x (local): int|error
+  y (local): int|error
+
+# Diagnostics
+  (none)
+### TITLE ###
+CatchBlockOnTypedLocalUsesDeclaredErrorArm
+### DESCRIPTION ###
+Typed local `x: int|error`. Inside the catch the override is the
+error arm specifically.
+### INPUT ###
+x: int|error = parse_int("hi") catch:
+    print(x)
+    yield 0
+### STDOUT ###
+# Identifier types
+  x @ 1:1 -> <no-type>
+  parse_int @ 1:16 -> dynamic
+  print @ 2:5 -> dynamic
+  x @ 2:11 -> error
+
+# Symbol types
+  x (local): int|error
+
+# Diagnostics
+  (none)

rts/check/type_check.go

@@ -729,16 +729,43 @@ func (tc *typeChecker) walkAssign(a *rl.Assign) {
 		tc.info.SymbolTypes[sym] = valType
 		tc.frame = tc.frame.With(sym, valType)
 	}
-	// Walk the catch block (if any) so hover and sub-expression type
-	// info inside the catch are recorded. The catch executes when the
-	// RHS errors, so identifier reads inside it could in principle
-	// see the assignment target as type `error`; we don'\''t narrow
-	// that yet because the AST doesn'\''t carry an explicit binding for
-	// the caught error (the user references the assignment target
-	// directly), and the runtime semantics aren'\''t covered by a
-	// single-Symbol narrowing.
+	// Walk the catch block (if any) with assignment targets narrowed
+	// to their error component. The catch runs when the RHS errored,
+	// so each target currently holds an error value - inside the
+	// catch body, reads of the target should see `error`, not the
+	// non-error narrowing walkAssign just installed in the frame.
+	//
+	// For a typed local `x: int|error = parse_int(...)` the override
+	// is the error arm of the declared type. For an unannotated
+	// local where the RHS synthed to int|error, we pick out the
+	// error arm. Falls back to a bare TypingErrorT when we can'\''t
+	// extract one (the runtime guarantee is "RHS errored," so error
+	// is always sound).
 	if a.Catch != nil {
+		savedFrame := tc.frame
+		overrides := make(map[*Symbol]rl.TypingT, len(a.Targets))
+		for i, target := range a.Targets {
+			ident, ok := target.(*rl.Identifier)
+			if !ok {
+				continue
+			}
+			sym, ok := tc.resolved.Uses[ident]
+			if !ok || sym == nil {
+				continue
+			}
+			var rhsType rl.TypingT
+			if i < len(a.Values) {
+				rhsType = tc.synth(a.Values[i])
+			}
+			errArm := extractErrorFrom(rhsType)
+			if errArm == nil {
+				errArm = rl.NewErrorType()
+			}
+			overrides[sym] = errArm
+		}
+		tc.frame = tc.frame.WithMany(overrides)
 		tc.walkStmts(a.Catch.Stmts)
+		tc.frame = savedFrame
 	}
 }