fix: add overlap safety check and diagnostics to FillGrid Step 2

FillGrid had no overlap check after perpendicular tiling of the row
pattern (Step 2), unlike Step 1 which had one. When geometry-aware
FindPatternCopyDistance underestimated row spacing, overlapping parts
were returned unchecked.

Changes:
- Make FillLinear.HasOverlappingParts shape-aware (bbox pre-filter +
  Part.Intersects) instead of bbox-only, preventing false positives on
  interlocking pairs while catching real overlaps
- Add missing overlap safety check after Step 2 perpendicular tiling
  with bbox fallback
- Add diagnostic Debug.WriteLine logging when overlap fallback triggers,
  including engine label, step, direction, work area, spacing, pattern
  details, and overlapping part locations/rotations for reproduction
- Add FillLinear.Label property set at all callsites for log traceability
- Refactor LinearFillStrategy and ExtentsFillStrategy to use shared
  FillHelpers.BestOverAngles helper for angle-sweep logic

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

OpenNest.Engine/Strategies/FillHelpers.cs

@@ -110,6 +110,49 @@ namespace OpenNest.Engine.Strategies
             return fallback ?? new List<Part>();
         }
 
+        /// <summary>
+        /// Sweeps a list of angles, calling fillAtAngle for each, and returns
+        /// the best result according to the context's comparer. Handles
+        /// cancellation and progress reporting.
+        /// </summary>
+        public static List<Part> BestOverAngles(
+            FillContext context,
+            IReadOnlyList<double> angles,
+            Func<double, List<Part>> fillAtAngle,
+            NestPhase phase,
+            string phaseLabel)
+        {
+            var workArea = context.WorkArea;
+            var comparer = context.Policy?.Comparer ?? new DefaultFillComparer();
+            List<Part> best = null;
+
+            for (var i = 0; i < angles.Count; i++)
+            {
+                context.Token.ThrowIfCancellationRequested();
+
+                var angle = angles[i];
+                var result = fillAtAngle(angle);
+                var angleDeg = Angle.ToDegrees(angle);
+
+                if (result != null && result.Count > 0)
+                {
+                    if (best == null || comparer.IsBetter(result, best, workArea))
+                        best = result;
+                }
+
+                NestEngineBase.ReportProgress(context.Progress, new ProgressReport
+                {
+                    Phase = phase,
+                    PlateNumber = context.PlateNumber,
+                    Parts = best,
+                    WorkArea = workArea,
+                    Description = $"{phaseLabel}: {i + 1}/{angles.Count} angles, {angleDeg:F0}° best = {best?.Count ?? 0} parts",
+                });
+            }
+
+            return best ?? new List<Part>();
+        }
+
         /// <summary>
         /// Checks if any pair of parts geometrically overlap. Uses bounding box
         /// pre-filtering for performance, then falls back to shape intersection.