feat(check): not / and / or narrowing predicates

Wires `not <cond>`, `<cond> and <cond>`, `<cond> or <cond>` into
interpretCondition. The Refinement.Negate method (previously dead
code) becomes the implementation of `not`; the binary cases follow
standard short-circuit narrowing semantics.

`not c`: flip truthy and falsy.

`a and b`:
  - WhenTrue: both truthy. Apply a's WhenTrue, then merge b's
    WhenTrue on top. b is computed against the a-truthy frame, so
    its refinement reflects what's known at that point in the
    short-circuit evaluation. Example:
    `if x != null and y != null:` narrows both x and y.
  - WhenFalse: at least one falsy. This is a disjunction we can't
    express as a single refinement map without losing info, so we
    leave it empty. Matches Pyright/mypy.

`a or b`: mirror image of and.
  - WhenFalse: both falsy. Sequential apply.
  - WhenTrue: at least one truthy, conservatively empty.

Right-operand frame matters. For `if x != null and x.field > 5:`,
the right hand x.field needs x narrowed to non-null - otherwise the
field-access narrowing logic would be working from the original
nullable type. interpretAnd / interpretOr build the right-side
frame by layering the appropriate left-side refinement before
interpreting the right.

mergeRefinementMaps overlays the right's narrowings on top of the
left's. When both refine the same symbol, the right wins because
it was computed in the tighter frame. Concretely:
`if x != null and type_of(x) == "int":` - left says x is int (non-
null), right (under that frame) further says x is int. Right wins
since they agree; if right had refined further (e.g. x is the int
arm of a union), that tighter narrowing would survive.

Combined with the Negate-based not, this unlocks the De Morgan
patterns too: `if not (x == null or y == null):` correctly
narrows both x and y to non-null, by flipping or's WhenFalse
(both non-null) into the outer WhenTrue.

Five new snapshot cases cover: bare not, simple and-chain, the
short-circuit "right sees left" property, or's symmetric falsy
narrowing in the else branch, and the De Morgan composition.

Author: amterp

rts/check/snapshots/narrow/compound.snap

@@ -0,0 +1,139 @@
+### TITLE ###
+NotInvertsRefinement
+### DESCRIPTION ###
+`if not (x == null):` should be equivalent to `if x != null:` -
+truthy branch narrows x to non-null.
+### INPUT ###
+fn f(x: int?):
+    if not (x == null):
+        y = x
+### STDOUT ###
+# Identifier types
+  x @ 2:13 -> int?
+  y @ 3:9 -> <no-type>
+  x @ 3:13 -> int
+
+# Symbol types
+  f (fn): <no-type>
+  x (param): int?
+  y (local): int
+
+# Diagnostics
+  (none)
+### TITLE ###
+AndChainsRefinements
+### DESCRIPTION ###
+`if x != null and y != null:` should narrow both x and y to non-null
+in the body. The right operand is evaluated with the left's truthy
+refinement active.
+### INPUT ###
+fn f(x: int?, y: str?):
+    if x != null and y != null:
+        a = x
+        b = y
+### STDOUT ###
+# Identifier types
+  x @ 2:8 -> int?
+  y @ 2:22 -> str?
+  a @ 3:9 -> <no-type>
+  x @ 3:13 -> int
+  b @ 4:9 -> <no-type>
+  y @ 4:13 -> str
+
+# Symbol types
+  a (local): int
+  b (local): str
+  f (fn): <no-type>
+  x (param): int?
+  y (param): str?
+
+# Diagnostics
+  (none)
+### TITLE ###
+AndShortCircuitRightSeesLeftNarrowed
+### DESCRIPTION ###
+In `x != null and type_of(x) == "int"`, the right hand sees x as
+non-null (left's truthy refinement). With base type int?, the
+right operand's narrowing to int is still useful (type_of can
+further refine within the non-null component).
+### INPUT ###
+fn f(x: int?):
+    if x != null and type_of(x) == "int":
+        y = x
+### STDOUT ###
+# Identifier types
+  x @ 2:8 -> int?
+  type_of @ 2:22 -> dynamic
+  x @ 2:30 -> int?
+  y @ 3:9 -> <no-type>
+  x @ 3:13 -> int
+
+# Symbol types
+  f (fn): <no-type>
+  x (param): int?
+  y (local): int
+
+# Diagnostics
+  (none)
+### TITLE ###
+OrFalsyBothFalse
+### DESCRIPTION ###
+`if x == null or y == null:` truthy = at least one is null (no
+refinement we can express). Falsy = both non-null - narrows both
+in the else.
+### INPUT ###
+fn f(x: int?, y: str?):
+    if x == null or y == null:
+        a = 0
+    else:
+        b = x
+        c = y
+### STDOUT ###
+# Identifier types
+  x @ 2:8 -> int?
+  y @ 2:21 -> str?
+  a @ 3:9 -> <no-type>
+  b @ 5:9 -> <no-type>
+  x @ 5:13 -> int
+  c @ 6:9 -> <no-type>
+  y @ 6:13 -> str
+
+# Symbol types
+  a (local): int
+  b (local): int
+  c (local): str
+  f (fn): <no-type>
+  x (param): int?
+  y (param): str?
+
+# Diagnostics
+  (none)
+### TITLE ###
+NotAndDeMorgan
+### DESCRIPTION ###
+`not (x == null or y == null)` should give us "both non-null"
+via the Negate path - flipping or's WhenFalse into the outer
+WhenTrue.
+### INPUT ###
+fn f(x: int?, y: str?):
+    if not (x == null or y == null):
+        a = x
+        b = y
+### STDOUT ###
+# Identifier types
+  x @ 2:13 -> int?
+  y @ 2:26 -> str?
+  a @ 3:9 -> <no-type>
+  x @ 3:13 -> int
+  b @ 4:9 -> <no-type>
+  y @ 4:13 -> str
+
+# Symbol types
+  a (local): int
+  b (local): str
+  f (fn): <no-type>
+  x (param): int?
+  y (param): str?
+
+# Diagnostics
+  (none)