Add additional test coverage to UP008 for pyupgrade parity (astral-sh#24264)

## Summary

See:
astral-sh#24001 (comment).

Author: charliermarsh

crates/ruff_linter/resources/test/fixtures/pyupgrade/UP008.py

@@ -36,12 +36,33 @@ def normal(self):
         super(MyClass, self).f()  # can use super()
         super().f()
 
+    def different_class(self):
+        super(BaseClass, self).f()  # CANNOT use super()
+
     def different_argument(self, other):
         super(MyClass, other).f()  # CANNOT use super()
 
     def comprehension_scope(self):
         [super(MyClass, self).f() for x in [1]]  # CANNOT use super()
 
+    def comprehension_scope_set(self):
+        {super(MyClass, self).f() for x in [1]}  # CANNOT use super()
+
+    def comprehension_scope_generator(self):
+        (super(MyClass, self).f() for x in [1])  # CANNOT use super()
+
+    def comprehension_scope_dict(self):
+        {True: super(MyClass, self).f() for x in [1]}  # CANNOT use super()
+
+    def nested_comprehension_scope(self):
+        [
+            (
+                [x for x in [1]],
+                super(MyClass, self).f(),
+            )
+            for _ in [1]
+        ]  # CANNOT use super()
+
     def inner_functions(self):
         def outer_argument():
             super(MyClass, self).f()  # CANNOT use super()
@@ -53,6 +74,10 @@ def inner_argument(self):
         outer_argument()
         inner_argument(self)
 
+    def lambda_closure(self):
+        g = lambda: super(MyClass, self).f()  # CANNOT use super()
+        g()
+
     def inner_class(self):
         class InnerClass:
             super(MyClass, self).f()  # CANNOT use super()
@@ -64,7 +89,6 @@ def method(inner_self):
 
     defined_outside = defined_outside
 
-
 from dataclasses import dataclass
 
 
@@ -318,6 +342,23 @@ def __init__(self, foo):
             super(Outer.Inner, self).__init__(foo)  # UP008: matches enclosing class chain
 
 
+# See: https://github.com/astral-sh/ruff/issues/24001
+# Bare and partially qualified class names should not match nested classes.
+class CommonNesting:
+    class C(Base):
+        def __init__(self, foo):
+            # TODO(charlie): false positive until nested class matching is fixed.
+            super(C, self).__init__(foo)  # Should NOT trigger UP008
+
+
+class HigherLevelsOfNesting:
+    class Inner:
+        class C(Base):
+            def __init__(self, foo):
+                # TODO(charlie): false positive until nested class matching is fixed.
+                super(Inner.C, self).__init__(foo)  # Should NOT trigger UP008
+
+
 # super() first arg is an attribute that only matches on the last segment,
 # but refers to a different class (Outer.Inner, not __class__ which is Inner).
 class Inner(Outer.Inner):
@@ -343,3 +384,36 @@ class Inner(Base):
         def __init__(self, foo):
             super(Wrong.Inner, self).__init__(foo)  # Should NOT trigger UP008
 
+
+class Whitespace(BaseClass):
+    def f(self):
+        super (Whitespace, self).f()  # can use super()
+
+
+def function_local():
+    class LocalOuter:
+        class LocalInner(BaseClass):
+            def f(self):
+                super(LocalOuter.LocalInner, self).f()  # can use super()
+
+
+class LambdaMethod(BaseClass):
+    # TODO(charlie): class-body lambda rewrite is still missed.
+    f = lambda self: super(LambdaMethod, self).f()  # can use super()
+
+
+class ClassMethod(BaseClass):
+    @classmethod
+    def f(cls):
+        super(ClassMethod, cls).f()  # can use super()
+
+
+class AsyncMethod(BaseClass):
+    async def f(self):
+        super(AsyncMethod, self).f()  # can use super()
+
+
+class OuterWithWhitespace:
+    class Inner(BaseClass):
+        def f(self):
+            super (OuterWithWhitespace.Inner, self).f()  # can use super()