Keep the G-code identical to main on Clipper2

Since main moved to Clipper2, parts of this branch no longer gave the same
G-code as main:

- bridge_over_infill dropped expand(limiting_area, 0.3 * flow.spacing()) as
  a no-op. The offset is below one unit, but Clipper2 still unites its
  result, which splits and merges touching polygons and so changes the
  anchor lines. Running it on the polygons next to the bridge gives main's
  anchors without the whole-layer pass.
- tsp_remove_crossings stopped at the first repeated ordering, where main
  runs on to its pn * pn cap. The loop is periodic from that point, so it
  now takes only the steps to the ordering main stops on.
- With a single tile, the tiled booleans now make the plain call instead of
  cutting the clip to the tile first.

The tiled boolean test compared rings exactly. With the safety offset a tile
unites only the clip polygons near it, and Clipper2 can then round a
crossing 1 unit differently, so that case allows 1 unit.

Comments that named ClipperLib now say Clipper, and
docs/HLSD/polygon-clipping.md describes the tiled booleans.

G-code of the five handy models in four configurations and of a baked
texture relief is byte-identical to main. Colour-painted models still
differ: segmenting each island on its own splits a colour's region into
different pieces than one diagram over the layer, which on one model also
changes the first layer's tool order.

src/libslic3r/GCode/OrderingStrategies.cpp

@@ -10,7 +10,6 @@
 #include <limits>
 #include <numeric>
 #include <unordered_map>
-#include <unordered_set>
 #include <utility>
 #include <vector>
 
@@ -188,26 +187,34 @@ bool tsp_remove_crossings(std::vector<size_t>& path, const Points& centers)
 
     // Process crossings one at a time: find first, reverse it, restart scan.
     // Cap iterations to prevent infinite loops on collinear/overlapping segments.
-    int max_iters = static_cast<int>(pn * pn);
+    const int max_iters = static_cast<int>(pn * pn);
     bool improved = false;
     // Reversing between two segments that only touch or overlap along a line need not remove the intersection, so on
     // islands laid out on a regular grid (a tiled texture, an array of parts) the loop can cycle through the same
-    // orderings until the pn * pn cap. Stop as soon as an ordering repeats; up to that point this is the same loop.
-    std::unordered_set<uint64_t> seen_paths;
+    // orderings until the pn * pn cap. Once an ordering repeats the rest of the loop is periodic, so only the steps
+    // to the ordering the capped loop would have stopped on are taken.
+    std::unordered_map<uint64_t, int> seen_paths; // path hash -> reversals done when it was reached
     const auto path_hash = [&path]() {
         uint64_t h = 1469598103934665603ull; // FNV-1a
         for (size_t idx : path)
             h = (h ^ uint64_t(idx)) * 1099511628211ull;
         return h;
     };
-    seen_paths.insert(path_hash());
-    while (max_iters-- > 0) {
+    const auto reverse_first_crossing = [&]() {
         auto [ci, cj] = pn >= grid_min_size ? find_crossing_grid() : find_crossing();
-        if (ci == std::numeric_limits<size_t>::max()) break;
-        improved = true;
+        if (ci == std::numeric_limits<size_t>::max())
+            return false;
         std::reverse(path.begin() + ci + 1, path.begin() + cj + 1);
-        if (!seen_paths.insert(path_hash()).second)
+        return true;
+    };
+    seen_paths.emplace(path_hash(), 0);
+    for (int iter = 1; iter <= max_iters && reverse_first_crossing(); ++iter) {
+        improved = true;
+        if (auto [it, inserted] = seen_paths.emplace(path_hash(), iter); !inserted) {
+            for (int steps = (max_iters - iter) % (iter - it->second); steps > 0; --steps)
+                reverse_first_crossing();
             break;
+        }
     }
     return improved;
 }