[red-knot] Inference for comparison of union types (#13781)

## Summary

Add type inference for comparisons involving union types. For example:
```py
one_or_two = 1 if flag else 2

reveal_type(one_or_two <= 2)  # revealed: Literal[True]
reveal_type(one_or_two <= 1)  # revealed: bool
reveal_type(one_or_two <= 0)  # revealed: Literal[False]
```

closes #13779

## Test Plan

See `resources/mdtest/comparison/unions.md`

crates/red_knot_python_semantic/src/types.rs

@@ -415,6 +415,11 @@ impl<'db> Type<'db> {
             (_, Type::Unknown | Type::Any | Type::Todo) => false,
             (Type::Never, _) => true,
             (_, Type::Never) => false,
+            (Type::BooleanLiteral(_), Type::Instance(class))
+                if class.is_known(db, KnownClass::Bool) =>
+            {
+                true
+            }
             (Type::IntLiteral(_), Type::Instance(class)) if class.is_known(db, KnownClass::Int) => {
                 true
             }

crates/red_knot_python_semantic/src/types/builder.rs

@@ -374,6 +374,12 @@ mod tests {
 
         let union = UnionType::from_elements(&db, [t0, t1, t2, t3]).expect_union();
         assert_eq!(union.elements(&db), &[bool_instance_ty, t3]);
+
+        let result_ty = UnionType::from_elements(&db, [bool_instance_ty, t0]);
+        assert_eq!(result_ty, bool_instance_ty);
+
+        let result_ty = UnionType::from_elements(&db, [t0, bool_instance_ty]);
+        assert_eq!(result_ty, bool_instance_ty);
     }
 
     #[test]

crates/red_knot_python_semantic/src/types/infer.rs

@@ -57,7 +57,7 @@ use crate::types::{
 };
 use crate::Db;
 
-use super::KnownClass;
+use super::{KnownClass, UnionBuilder};
 
 /// Infer all types for a [`ScopeId`], including all definitions and expressions in that scope.
 /// Use when checking a scope, or needing to provide a type for an arbitrary expression in the
@@ -2711,6 +2711,21 @@ impl<'db> TypeInferenceBuilder<'db> {
         // - `[ast::CompOp::Is]`: return `false` if unequal, `bool` if equal
         // - `[ast::CompOp::IsNot]`: return `true` if unequal, `bool` if equal
         match (left, right) {
+            (Type::Union(union), other) => {
+                let mut builder = UnionBuilder::new(self.db);
+                for element in union.elements(self.db) {
+                    builder = builder.add(self.infer_binary_type_comparison(*element, op, other)?);
+                }
+                Some(builder.build())
+            }
+            (other, Type::Union(union)) => {
+                let mut builder = UnionBuilder::new(self.db);
+                for element in union.elements(self.db) {
+                    builder = builder.add(self.infer_binary_type_comparison(other, op, *element)?);
+                }
+                Some(builder.build())
+            }
+
             (Type::IntLiteral(n), Type::IntLiteral(m)) => match op {
                 ast::CmpOp::Eq => Some(Type::BooleanLiteral(n == m)),
                 ast::CmpOp::NotEq => Some(Type::BooleanLiteral(n != m)),
@@ -2902,6 +2917,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                     }
                 }
             }
+
             // Lookup the rich comparison `__dunder__` methods on instances
             (Type::Instance(left_class_ty), Type::Instance(right_class_ty)) => match op {
                 ast::CmpOp::Lt => {
@@ -2911,7 +2927,10 @@ impl<'db> TypeInferenceBuilder<'db> {
                 _ => Some(Type::Todo),
             },
             // TODO: handle more types
-            _ => Some(Type::Todo),
+            _ => match op {
+                ast::CmpOp::Is | ast::CmpOp::IsNot => Some(KnownClass::Bool.to_instance(self.db)),
+                _ => Some(Type::Todo),
+            },
         }
     }