[ty] Fix panic due to simplifying Divergent types out of intersections types

[mtshiba]

Summary

While investigating the cause of the panics seen since #20962, I found that intersection types containing Divergent types were incorrectly reduced by unioning them with another dynamic types.
This prevents tracking of Divergent types in fixed-point iteration.

This PR fixes the logic of Type::is_redundant_with to prevent the panic from occurring.

(BTW, another panic in pr_20962_comprehension_panics.md has been confirmed to disappear by #20566)

Test Plan

corpus/cyclic_comprehensions.py is added.

[github-actions]

Diagnostic diff on typing conformance tests

No changes detected when running ty on typing conformance tests ✅

[github-actions]

mypy_primer results

No ecosystem changes detected ✅
No memory usage changes detected ✅

[AlexWaygood]

Nice, thank you!

I was initially confused about why we didn't need this for the branch above this, but I see that it should be handled by an earlier branch. We could possibly add a debug_assert!() for the benefit of future readers:

diff --git a/crates/ty_python_semantic/src/types.rs b/crates/ty_python_semantic/src/types.rs
index 6efa8950f2..45a4b2aad5 100644
--- a/crates/ty_python_semantic/src/types.rs
+++ b/crates/ty_python_semantic/src/types.rs
@@ -1699,15 +1699,22 @@ impl<'db> Type<'db> {
             // holds true if `T` is also a dynamic type or a union that contains a dynamic type.
             // Similarly, `T <: Any` only holds true if `T` is a dynamic type or an intersection
             // that contains a dynamic type.
-            (Type::Dynamic(_), _) => ConstraintSet::from(match relation {
-                TypeRelation::Subtyping => false,
-                TypeRelation::Assignability => true,
-                TypeRelation::Redundancy => match target {
-                    Type::Dynamic(_) => true,
-                    Type::Union(union) => union.elements(db).iter().any(Type::is_dynamic),
-                    _ => false,
-                },
-            }),
+            (Type::Dynamic(dynamic), _) => {
+                // If a `Divergent` type is involved, it must not be eliminated.
+                debug_assert!(
+                    !matches!(dynamic, DynamicType::Divergent(_)),
+                    "DynamicType::Divergent should have been handled in an earlier branch"
+                );
+                ConstraintSet::from(match relation {
+                    TypeRelation::Subtyping => false,
+                    TypeRelation::Assignability => true,
+                    TypeRelation::Redundancy => match target {
+                        Type::Dynamic(_) => true,
+                        Type::Union(union) => union.elements(db).iter().any(Type::is_dynamic),
+                        _ => false,
+                    },
+                })
+            }
             (_, Type::Dynamic(_)) => ConstraintSet::from(match relation {
                 TypeRelation::Subtyping => false,
                 TypeRelation::Assignability => true,

[carljm]

Especially with the changes in #20566, I start to wonder if Divergent should perhaps not be a variant of Dynamic at all, or if it would be less error-prone to make it a distinct top-level Type so we have to consider its behavior separately.