gh-129210: Avoid list traversal if skipping resurrection checks

If we don't need to repeat the unreachable check we can track the number of
objects being collected as a side-effect of previous operations and avoid doing
a list traversal to count them.

In my environment and testing this gives an additional ~5% performance
improvement on top of the previous change for the gh-129210 micro-benchmark.

Author: duaneg

Python/gc.c

@@ -775,10 +775,13 @@ has_legacy_finalizer(PyObject *op)
  *
  * This function also removes NEXT_MASK_UNREACHABLE flag
  * from _gc_next in unreachable.
+ *
+ * Returns the number of items remaining in the `unreachable` list.
  */
-static void
+static Py_ssize_t
 move_legacy_finalizers(PyGC_Head *unreachable, PyGC_Head *finalizers)
 {
+    Py_ssize_t count = 0;
     PyGC_Head *gc, *next;
     _PyObject_ASSERT(
         FROM_GC(unreachable),
@@ -797,8 +800,11 @@ move_legacy_finalizers(PyGC_Head *unreachable, PyGC_Head *finalizers)
         if (has_legacy_finalizer(op)) {
             gc_clear_collecting(gc);
             gc_list_move(gc, finalizers);
+        } else {
+            ++count;
         }
     }
+    return count;
 }
 
 static inline void
@@ -1072,7 +1078,7 @@ handle_legacy_finalizers(PyThreadState *tstate,
 
 /* Run first-time finalizers (if any) on all the objects in collectable.
  * Note that this may remove some (or even all) of the objects from the
- * list, due to refcounts falling to 0.
+ * list, due to refcounts falling to 0. Return the number of finalizers run.
  */
 static int
 finalize_garbage(PyThreadState *tstate, PyGC_Head *collectable)
@@ -1717,7 +1723,8 @@ gc_collect_region(PyThreadState *tstate,
     gc_list_init(&finalizers);
     // NEXT_MASK_UNREACHABLE is cleared here.
     // After move_legacy_finalizers(), unreachable is normal list.
-    move_legacy_finalizers(&unreachable, &finalizers);
+    Py_ssize_t unreachable_count = move_legacy_finalizers(&unreachable, &finalizers);
+
     /* finalizers contains the unreachable objects with a legacy finalizer;
      * unreachable objects reachable *from* those are also uncollectable,
      * and we move those into the finalizers list too.
@@ -1734,6 +1741,7 @@ gc_collect_region(PyThreadState *tstate,
 
     /* Clear weakrefs and invoke callbacks as necessary. */
     stats->collected += handle_weakrefs(&unreachable, to);
+
     gc_list_validate_space(to, gcstate->visited_space);
     validate_list(to, collecting_clear_unreachable_clear);
     validate_list(&unreachable, collecting_set_unreachable_clear);
@@ -1750,15 +1758,17 @@ gc_collect_region(PyThreadState *tstate,
     gc_list_init(&final_unreachable);
     if (check_resurrected) {
         handle_resurrected_objects(&unreachable, &final_unreachable, to);
+        unreachable_count = gc_list_size(&final_unreachable);
     } else {
         gc_list_merge(&unreachable, &final_unreachable);
+        assert(unreachable_count == gc_list_size(&final_unreachable));
     }
 
     /* Call tp_clear on objects in the final_unreachable set.  This will cause
     * the reference cycles to be broken.  It may also cause some objects
     * in finalizers to be freed.
     */
-    stats->collected += gc_list_size(&final_unreachable);
+    stats->collected += unreachable_count;
     delete_garbage(tstate, gcstate, &final_unreachable, to);
 
     /* Collect statistics on uncollectable objects found and print