[red-knot] - Flow-control for boolean operations (#13940)

## Summary

As python uses short-circuiting boolean operations in runtime, we should
mimic that logic in redknot as well.
For example, we should detect that in the following code `x` might be
undefined inside the block:

```py
if flag or (x := 1):
    print(x) 
```

## Test Plan

Added mdtest suit for boolean expressions.

---------

Co-authored-by: Carl Meyer <carl@astral.sh>

crates/red_knot_python_semantic/resources/mdtest/boolean/short_circuit.md

@@ -0,0 +1,78 @@
+# Short-Circuit Evaluation
+
+## Not all boolean expressions must be evaluated
+
+In `or` expressions, if the left-hand side is truthy, the right-hand side is not evaluated.
+Similarly, in `and` expressions, if the left-hand side is falsy, the right-hand side is not
+evaluated.
+
+```py
+def bool_instance() -> bool:
+    return True
+
+if bool_instance() or (x := 1):
+    # error: [possibly-unresolved-reference]
+    reveal_type(x)  # revealed: Unbound | Literal[1]
+
+if bool_instance() and (x := 1):
+    # error: [possibly-unresolved-reference]
+    reveal_type(x)  # revealed: Unbound | Literal[1]
+```
+
+## First expression is always evaluated
+
+```py
+def bool_instance() -> bool:
+    return True
+
+if (x := 1) or bool_instance():
+    reveal_type(x)  # revealed: Literal[1]
+
+if (x := 1) and bool_instance():
+    reveal_type(x)  # revealed: Literal[1]
+```
+
+## Statically known truthiness
+
+```py
+if True or (x := 1):
+    # TODO: infer that the second arm is never executed so type should be just "Unbound".
+    # error: [possibly-unresolved-reference]
+    reveal_type(x)  # revealed: Unbound | Literal[1]
+
+if True and (x := 1):
+    # TODO: infer that the second arm is always executed so type should be just "Literal[1]".
+    # error: [possibly-unresolved-reference]
+    reveal_type(x)  # revealed: Unbound | Literal[1]
+```
+
+## Later expressions can always use variables from earlier expressions
+
+```py
+def bool_instance() -> bool:
+    return True
+
+bool_instance() or (x := 1) or reveal_type(x)  # revealed: Literal[1]
+
+# error: [unresolved-reference]
+bool_instance() or reveal_type(y) or (y := 1)  # revealed: Unbound
+```
+
+## Nested expressions
+
+```py
+def bool_instance() -> bool:
+    return True
+
+if bool_instance() or ((x := 1) and bool_instance()):
+    # error: "Name `x` used when possibly not defined"
+    reveal_type(x)  # revealed: Unbound | Literal[1]
+
+if ((y := 1) and bool_instance()) or bool_instance():
+    reveal_type(y)  # revealed: Literal[1]
+
+# error: [possibly-unresolved-reference]
+if (bool_instance() and (z := 1)) or reveal_type(z):  # revealed: Unbound | Literal[1]
+    # error: [possibly-unresolved-reference]
+    reveal_type(z)  # revealed: Unbound | Literal[1]
+```

crates/red_knot_python_semantic/src/semantic_index/builder.rs

@@ -1106,6 +1106,27 @@ where
                     },
                 );
             }
+            ast::Expr::BoolOp(ast::ExprBoolOp {
+                values,
+                range: _,
+                op: _,
+            }) => {
+                // TODO detect statically known truthy or falsy values (via type inference, not naive
+                // AST inspection, so we can't simplify here, need to record test expression for
+                // later checking)
+                let mut snapshots = vec![];
+
+                for (index, value) in values.iter().enumerate() {
+                    // The first item of BoolOp is always evaluated
+                    if index > 0 {
+                        snapshots.push(self.flow_snapshot());
+                    }
+                    self.visit_expr(value);
+                }
+                for snapshot in snapshots {
+                    self.flow_merge(snapshot);
+                }
+            }
             _ => {
                 walk_expr(self, expr);
             }