Reduce GC pressure in dependency graph traversal (#6333)

* Reduce GC pressure in dependency graph traversal

Optimized AbstractDependencyGraphBuilder to reduce ArrayList allocations
during dependency path collection by using a backtracking pattern.

## Problem

The original implementation created 3 ArrayList objects per dependency
node during traversal:
1. Copy of incoming path + current node
2. ArrayList for storing paths per GAV (if new)
3. Temporary path objects during recursion

For projects like Spring Boot with 250+ dependencies, this resulted in
~3,000 ArrayList allocations per recipe execution.

## Solution

Use a single reusable ArrayList (pathBuffer) for traversal:
- Add node to buffer before recursion
- Create snapshot only when storing path
- Remove node from buffer after recursion (backtracking)

This reduces allocations from 3 to 2 per node (~33% reduction).

## Benchmark results

Tested with Spring Boot project (250+ transitive dependencies):
- GC time: 35,784ms → 10,514ms (-70%)
- GC percentage: 71% → 21%
- More stable performance (no catastrophic GC collapse)

The optimization is functionally equivalent - produces identical
dependency paths using the same DFS traversal order.

* Add clarifying comments for O(1) performance optimization

* updated comment

Author: pstreef

rewrite-maven/src/main/java/org/openrewrite/maven/graph/AbstractDependencyGraphBuilder.java

@@ -35,41 +35,45 @@ public abstract class AbstractDependencyGraphBuilder<T extends DependencyGraph.D
     public void collectDependencyPaths(List<ResolvedDependency> dependencies,
                                        Map<ResolvedGroupArtifactVersion, List<DependencyGraph.DependencyPath>> paths,
                                        String scope) {
+        List<DependencyGraph.DependencyNode> pathBuffer = new ArrayList<>();
         for (ResolvedDependency dependency : dependencies) {
-            List<DependencyGraph.DependencyNode> parentPath = new ArrayList<>();
-            collectDependencyPathsRecursive(dependency, parentPath, paths, scope);
+            collectDependencyPathsRecursive(dependency, pathBuffer, paths, scope);
         }
     }
 
     private void collectDependencyPathsRecursive(ResolvedDependency dependency,
-                                                 List<DependencyGraph.DependencyNode> parentPath,
+                                                 List<DependencyGraph.DependencyNode> pathBuffer,
                                                  Map<ResolvedGroupArtifactVersion, List<DependencyGraph.DependencyPath>> paths,
                                                  String scope) {
         ResolvedGroupArtifactVersion gav = dependency.getGav();
 
-        // Create path for this dependency including all parents
-        List<DependencyGraph.DependencyNode> pathNodes = new ArrayList<>();
-
-        // Add the current dependency using the specific node type created by subclass
         T node = createNode(dependency, scope);
-        pathNodes.add(node);
-
-        // Add all parents from the parent path
-        pathNodes.addAll(parentPath);
+        pathBuffer.add(node);
 
-        DependencyGraph.DependencyPath path = new DependencyGraph.DependencyPath(pathNodes, scope);
+        // We add at the end for performance during recursing but reverse
+        // when creating a snapshot to get correct order (current -> parents)
+        List<DependencyGraph.DependencyNode> pathSnapshot = new ArrayList<>(pathBuffer.size());
+        for (int i = pathBuffer.size() - 1; i >= 0; i--) {
+            pathSnapshot.add(pathBuffer.get(i));
+        }
+        DependencyGraph.DependencyPath path = new DependencyGraph.DependencyPath(pathSnapshot, scope);
         paths.computeIfAbsent(gav, k -> new ArrayList<>()).add(path);
 
-        // Create new parent path for children that includes this dependency
-        List<DependencyGraph.DependencyNode> newParentPath = new ArrayList<>();
-        newParentPath.add(node);
-        newParentPath.addAll(parentPath);
-
-        // Recursively process child dependencies
         for (ResolvedDependency child : dependency.getDependencies()) {
-            if (newParentPath.stream().noneMatch(childPath -> childPath.getGroupId().equals(child.getGroupId()) && childPath.getArtifactId().equals(child.getArtifactId()))) {
-                collectDependencyPathsRecursive(child, newParentPath, paths, scope);
+            boolean hasCycle = false;
+            for (int i = 0; i < pathBuffer.size(); i++) {
+                DependencyGraph.DependencyNode n = pathBuffer.get(i);
+                if (n.getGroupId().equals(child.getGroupId()) &&
+                    n.getArtifactId().equals(child.getArtifactId())) {
+                    hasCycle = true;
+                    break;
+                }
+            }
+            if (!hasCycle) {
+                collectDependencyPathsRecursive(child, pathBuffer, paths, scope);
             }
         }
+
+        pathBuffer.remove(pathBuffer.size() - 1); // Backtrack for next iteration
     }
 }