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/MultiMaterialSegmentation.cpp

@@ -1403,7 +1403,7 @@ static inline std::vector<std::vector<ExPolygons>> segmentation_top_and_bottom_l
     // `shell_layers`, nearest first), one more perimeter in on each, stopping at the first layer where nothing is left.
     // Only the slices within the deepest offset of `ex` (three times that with the miter joins) decide the result, so the
     // work is done per tile of `ex`'s ExPolygons on the slices cut to the tile's box grown by that much: the same result, but
-    // each ClipperLib call stays the size of a tile rather than of a layer cut through a fine relief, and the tiles run in
+    // each Clipper call stays the size of a tile rather than of a layer cut through a fine relief, and the tiles run in
     // parallel.
     const auto project_to_shells = [&input_expolygons](const ExPolygons &ex, size_t layer_idx, const std::vector<size_t> &shell_layers,
                                                        const LayerColorStat &stat, ShellProjections &dst) {
@@ -1965,7 +1965,7 @@ static std::vector<std::vector<ExPolygons>> merge_segmented_layers(const std::ve
     BOOST_LOG_TRIVIAL(debug) << "Print object segmentation - Merging segmented layers in parallel - Begin";
     // Every region of a layer is merged together with the regions of the islands it overlaps, and the islands are further
     // apart than the dimple removal below reaches, so this gives the same result as merging the layer at once. On a layer
-    // cut through a fine relief every region shares thousands of hole contours with every other, and ClipperLib, splitting
+    // cut through a fine relief every region shares thousands of hole contours with every other, and Clipper, splitting
     // and re-linking one huge polygon over and over, took anything up to half an hour for a layer; per island each operation
     // stays the size of the island, and the islands run in parallel.
     tbb::parallel_for(tbb::blocked_range<size_t>(0, num_layers), [&](const tbb::blocked_range<size_t> &range) {