perf(PlanarGraphAnalyzer): eliminate HashSet allocation in contraction strategies 2/3

In tryContractionStrategy cases 2 and 3 (common-neighbor heuristic),
replaced per-edge HashSet copy + retainAll with an allocation-free
counting loop that iterates the smaller neighbor set and probes the
larger one. Eliminates O(|E|) temporary HashSet allocations in the
inner loop of the minor-detection contraction phase.

Author: sauravbhattacharya001

Gvisual/src/gvisual/PlanarGraphAnalyzer.java

@@ -624,12 +624,20 @@ private static boolean tryContractionStrategy(Map<String, Set<String>> adj,
                     case 2: case 3: {
                         int bestCommon = (strategy == 2) ? -1 : Integer.MAX_VALUE;
                         for (String v : g.keySet()) {
-                            for (String n : g.get(v)) {
-                                Set<String> common = new HashSet<String>(g.get(v));
-                                common.retainAll(g.get(n));
-                                boolean better = (strategy == 2) ? common.size() > bestCommon : common.size() < bestCommon;
+                            Set<String> vNbrs = g.get(v);
+                            for (String n : vNbrs) {
+                                // Count common neighbors without allocating a temporary HashSet.
+                                // Previously created new HashSet<>(g.get(v)) + retainAll per pair.
+                                Set<String> nNbrs = g.get(n);
+                                Set<String> smaller = vNbrs.size() <= nNbrs.size() ? vNbrs : nNbrs;
+                                Set<String> larger  = smaller == vNbrs ? nNbrs : vNbrs;
+                                int commonCount = 0;
+                                for (String s : smaller) {
+                                    if (larger.contains(s)) commonCount++;
+                                }
+                                boolean better = (strategy == 2) ? commonCount > bestCommon : commonCount < bestCommon;
                                 if (better) {
-                                    bestCommon = common.size();
+                                    bestCommon = commonCount;
                                     toContract = v;
                                     bestNeighbor = n;
                                 }