feat: add reverse push directions for concave interlocking and cache best-fit results

Add PushDirection.Right and PushDirection.Up to RotationSlideStrategy so
parts can approach from all four directions. This discovers concave
interlocking arrangements (e.g. L-shaped parts nesting into each other's
cavities) that the original Left/Down-only slides could never reach.

Introduce BestFitCache so best-fit results are computed once at step size
0.25 and shared between the viewer and nesting engine. The GPU evaluator
factory is configured once at startup instead of being wired per call
site, and NestEngine.CreateEvaluator is removed.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

OpenNest.Engine/BestFit/BestFitCache.cs

@@ -0,0 +1,100 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+
+namespace OpenNest.Engine.BestFit
+{
+    public static class BestFitCache
+    {
+        private const double StepSize = 0.25;
+
+        private static readonly ConcurrentDictionary<CacheKey, List<BestFitResult>> _cache =
+            new ConcurrentDictionary<CacheKey, List<BestFitResult>>();
+
+        public static Func<Drawing, double, IPairEvaluator> CreateEvaluator { get; set; }
+
+        public static List<BestFitResult> GetOrCompute(
+            Drawing drawing, double plateWidth, double plateHeight,
+            double spacing)
+        {
+            var key = new CacheKey(drawing, plateWidth, plateHeight, spacing);
+
+            if (_cache.TryGetValue(key, out var cached))
+                return cached;
+
+            IPairEvaluator evaluator = null;
+
+            try
+            {
+                if (CreateEvaluator != null)
+                {
+                    try { evaluator = CreateEvaluator(drawing, spacing); }
+                    catch { /* fall back to default evaluator */ }
+                }
+
+                var finder = new BestFitFinder(plateWidth, plateHeight, evaluator);
+                var results = finder.FindBestFits(drawing, spacing, StepSize);
+
+                _cache.TryAdd(key, results);
+                return results;
+            }
+            finally
+            {
+                (evaluator as IDisposable)?.Dispose();
+            }
+        }
+
+        public static void Invalidate(Drawing drawing)
+        {
+            foreach (var key in _cache.Keys)
+            {
+                if (ReferenceEquals(key.Drawing, drawing))
+                    _cache.TryRemove(key, out _);
+            }
+        }
+
+        public static void Clear()
+        {
+            _cache.Clear();
+        }
+
+        private readonly struct CacheKey : IEquatable<CacheKey>
+        {
+            public readonly Drawing Drawing;
+            public readonly double PlateWidth;
+            public readonly double PlateHeight;
+            public readonly double Spacing;
+
+            public CacheKey(Drawing drawing, double plateWidth, double plateHeight, double spacing)
+            {
+                Drawing = drawing;
+                PlateWidth = plateWidth;
+                PlateHeight = plateHeight;
+                Spacing = spacing;
+            }
+
+            public bool Equals(CacheKey other)
+            {
+                return ReferenceEquals(Drawing, other.Drawing) &&
+                       PlateWidth == other.PlateWidth &&
+                       PlateHeight == other.PlateHeight &&
+                       Spacing == other.Spacing;
+            }
+
+            public override bool Equals(object obj) => obj is CacheKey other && Equals(other);
+
+            public override int GetHashCode()
+            {
+                unchecked
+                {
+                    var hash = RuntimeHelpers.GetHashCode(Drawing);
+                    hash = hash * 397 ^ PlateWidth.GetHashCode();
+                    hash = hash * 397 ^ PlateHeight.GetHashCode();
+                    hash = hash * 397 ^ Spacing.GetHashCode();
+                    return hash;
+                }
+            }
+        }
+    }
+}

OpenNest.Engine/BestFit/RotationSlideStrategy.cs

@@ -35,6 +35,16 @@ namespace OpenNest.Engine.BestFit
                 part1, part2Template, drawing, spacing, stepSize,
                 PushDirection.Down, candidates, ref testNumber);
 
+            // Try pushing right (approach from left — finds concave interlocking)
+            GenerateCandidatesForAxis(
+                part1, part2Template, drawing, spacing, stepSize,
+                PushDirection.Right, candidates, ref testNumber);
+
+            // Try pushing up (approach from below — finds concave interlocking)
+            GenerateCandidatesForAxis(
+                part1, part2Template, drawing, spacing, stepSize,
+                PushDirection.Up, candidates, ref testNumber);
+
             return candidates;
         }
 
@@ -77,11 +87,15 @@ namespace OpenNest.Engine.BestFit
             {
                 var part2 = (Part)part2Template.Clone();
 
-                // Place part2 far away along push axis, at perpendicular offset
+                // Place part2 far away along push axis, at perpendicular offset.
+                // Left/Down: start on the positive side; Right/Up: start on the negative side.
+                var isPositiveStart = pushDir == PushDirection.Left || pushDir == PushDirection.Down;
+                var startPos = isPositiveStart ? pushStartOffset : -pushStartOffset;
+
                 if (isHorizontalPush)
-                    part2.Offset(pushStartOffset, offset);
+                    part2.Offset(startPos, offset);
                 else
-                    part2.Offset(offset, pushStartOffset);
+                    part2.Offset(offset, startPos);
 
                 // Get part2's offset lines (half-spacing outward)
                 var part2Lines = Helper.GetOffsetPartLines(part2, halfSpacing);

OpenNest.Engine/NestEngine.cs

@@ -1,5 +1,4 @@
-using System;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
 using OpenNest.Engine.BestFit;
@@ -20,8 +19,6 @@ namespace OpenNest
 
         public NestDirection NestDirection { get; set; }
 
-        public Func<Drawing, double, IPairEvaluator> CreateEvaluator { get; set; }
-
         public bool Fill(NestItem item)
         {
             return Fill(item, Plate.WorkArea());
@@ -151,16 +148,9 @@ namespace OpenNest
 
         private List<Part> FillWithPairs(NestItem item, Box workArea)
         {
-            IPairEvaluator evaluator = null;
-
-            if (CreateEvaluator != null)
-            {
-                try { evaluator = CreateEvaluator(item.Drawing, Plate.PartSpacing); }
-                catch { /* GPU not available, fall back to geometry */ }
-            }
-
-            var finder = new BestFitFinder(Plate.Size.Width, Plate.Size.Height, evaluator);
-            var bestFits = finder.FindBestFits(item.Drawing, Plate.PartSpacing, stepSize: 0.25);
+            var bestFits = BestFitCache.GetOrCompute(
+                item.Drawing, Plate.Size.Width, Plate.Size.Height,
+                Plate.PartSpacing);
 
             var keptResults = bestFits.Where(r => r.Keep).Take(50).ToList();
             Debug.WriteLine($"[FillWithPairs] Total: {bestFits.Count}, Kept: {bestFits.Count(r => r.Keep)}, Trying: {keptResults.Count}");
@@ -187,8 +177,6 @@ namespace OpenNest
                     best = parts;
             }
 
-            (evaluator as IDisposable)?.Dispose();
-
             Debug.WriteLine($"[FillWithPairs] Best pair result: {best?.Count ?? 0} parts");
             return best ?? new List<Part>();
         }