chore(scripts): follow alias and attribute redirections in breaking-change detection

The script previously treated griffe.Alias as opaque (returning {} members).
This produced false positives for back-compat re-exports — both:
  * `from .new_path import NewClass` (Alias)
  * `OldName = NewClass` (Attribute with ExprName value)
  * `OldName = module.NewClass` (Attribute with ExprAttribute value)

Resolve each to the underlying class and report members from there. Real
breaking changes (class definition removed, attribute deleted from the
target class) are still flagged; false positives from intentional
back-compat aliases are not.

Author: NormallyGaussian

scripts/detect-breaking-changes.py

@@ -10,11 +10,70 @@
 from rich.style import Style
 
 
+def _resolve_redirect(obj: griffe.Object | griffe.Alias) -> griffe.Object | griffe.Alias | None:
+    """Follow back-compat redirections to a real class definition.
+
+    We use two patterns to preserve import paths after a schema rename:
+      * `from .new_path import NewClass` → `griffe.Alias`
+      * `OldName = NewClass` (module-level assignment) → `griffe.Attribute`
+    Both are runtime-equivalent re-exports and should expose the target
+    class's attributes for breaking-change detection. Without resolving them,
+    griffe reports every old attribute as removed.
+    """
+    visited: set[int] = set()
+    current: griffe.Object | griffe.Alias | None = obj
+    while current is not None and id(current) not in visited:
+        visited.add(id(current))
+        if isinstance(current, griffe.Alias):
+            try:
+                final = current.final_target
+            except Exception:
+                return None
+            if isinstance(final, griffe.Alias) or final is current:
+                return None
+            return final
+        if isinstance(current, griffe.Attribute):
+            value = current.value
+            parent = current.parent
+            if parent is None or value is None:
+                return None
+            if isinstance(value, griffe.ExprName):
+                next_obj = parent.members.get(str(value))
+                if next_obj is None:
+                    return None
+                current = next_obj
+                continue
+            if isinstance(value, griffe.ExprAttribute):
+                # Qualified path like `task_group_status.TaskGroupStatus`.
+                # Walk segment by segment, resolving any module aliases as we go.
+                next_obj: griffe.Object | griffe.Alias | None = parent
+                for segment in value.values:
+                    if not isinstance(segment, griffe.ExprName):
+                        continue
+                    if isinstance(next_obj, griffe.Alias):
+                        try:
+                            next_obj = next_obj.final_target
+                        except Exception:
+                            return None
+                    if next_obj is None or not hasattr(next_obj, "members"):
+                        return None
+                    next_obj = next_obj.members.get(str(segment))
+                if next_obj is None:
+                    return None
+                current = next_obj
+                continue
+            return None
+        return current
+    return None
+
+
 def public_members(obj: griffe.Object | griffe.Alias) -> dict[str, griffe.Object | griffe.Alias]:
+    target = _resolve_redirect(obj)
+    if target is not None and target is not obj:
+        obj = target
+
     if isinstance(obj, griffe.Alias):
-        # ignore imports for now, they're technically part of the public API
-        # but we don't have good preventative measures in place to prevent
-        # changing them
+        # Truly opaque alias we couldn't resolve.
         return {}
 
     return {name: value for name, value in obj.all_members.items() if not name.startswith("_")}