docs: update README with accurate features and add roadmap

Remove NFP pair fitting claim from features (not yet integrated).
Qualify lead-in/lead-out as engine-only (UI coming soon).
Mark --autonest CLI option as experimental. Add Roadmap section
with planned work: NFP nesting, lead-in UI, sheet cut-offs,
post-processors, and shape library UI.

Add documentation maintenance instruction to CLAUDE.md requiring
README.md and CLAUDE.md updates when project structure changes.

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

OpenNest.Engine/Fill/RotationAnalysis.cs

@@ -0,0 +1,124 @@
+using System.Collections.Generic;
+using System.Linq;
+using OpenNest.Converters;
+using OpenNest.Geometry;
+using OpenNest.Math;
+
+namespace OpenNest
+{
+    internal static class RotationAnalysis
+    {
+        /// <summary>
+        /// Finds the rotation angle that minimizes the bounding rectangle of a drawing's
+        /// largest shape, constrained by the NestItem's rotation range.
+        /// </summary>
+        public static double FindBestRotation(NestItem item)
+        {
+            var entities = ConvertProgram.ToGeometry(item.Drawing.Program)
+                .Where(e => e.Layer != SpecialLayers.Rapid);
+
+            var shapes = ShapeBuilder.GetShapes(entities);
+
+            if (shapes.Count == 0)
+                return 0;
+
+            // Find the largest shape (outer profile).
+            var largest = shapes[0];
+            var largestArea = largest.Area();
+
+            for (var i = 1; i < shapes.Count; i++)
+            {
+                var area = shapes[i].Area();
+                if (area > largestArea)
+                {
+                    largest = shapes[i];
+                    largestArea = area;
+                }
+            }
+
+            // Convert to polygon so arcs are properly represented as line segments.
+            // Shape.FindBestRotation() uses Entity cardinal points which are incorrect
+            // for arcs that don't sweep through all 4 cardinal directions.
+            var polygon = largest.ToPolygonWithTolerance(0.1);
+
+            BoundingRectangleResult result;
+
+            if (item.RotationStart.IsEqualTo(0) && item.RotationEnd.IsEqualTo(0))
+                result = polygon.FindBestRotation();
+            else
+                result = polygon.FindBestRotation(item.RotationStart, item.RotationEnd);
+
+            // Negate the angle to align the minimum bounding rectangle with the axes.
+            return -result.Angle;
+        }
+
+        /// <summary>
+        /// Computes the convex hull of the parts' geometry and returns the unique
+        /// edge angles, suitable for use as candidate rotation angles.
+        /// </summary>
+        public static List<double> FindHullEdgeAngles(List<Part> parts)
+        {
+            var points = new List<Vector>();
+
+            foreach (var part in parts)
+            {
+                var entities = ConvertProgram.ToGeometry(part.Program)
+                    .Where(e => e.Layer != SpecialLayers.Rapid);
+
+                var shapes = ShapeBuilder.GetShapes(entities);
+
+                foreach (var shape in shapes)
+                {
+                    var polygon = shape.ToPolygonWithTolerance(0.1);
+
+                    foreach (var vertex in polygon.Vertices)
+                        points.Add(vertex + part.Location);
+                }
+            }
+
+            if (points.Count < 3)
+                return new List<double> { 0 };
+
+            var hull = ConvexHull.Compute(points);
+            return GetHullEdgeAngles(hull);
+        }
+
+        public static List<double> GetHullEdgeAngles(Polygon hull)
+        {
+            var vertices = hull.Vertices;
+            var n = hull.IsClosed() ? vertices.Count - 1 : vertices.Count;
+
+            // Collect edges with their squared length so we can sort by longest first.
+            var edges = new List<(double angle, double lengthSq)>();
+
+            for (var i = 0; i < n; i++)
+            {
+                var next = (i + 1) % n;
+                var dx = vertices[next].X - vertices[i].X;
+                var dy = vertices[next].Y - vertices[i].Y;
+                var lengthSq = dx * dx + dy * dy;
+
+                if (lengthSq < Tolerance.Epsilon)
+                    continue;
+
+                var angle = -System.Math.Atan2(dy, dx);
+
+                if (!edges.Any(e => e.angle.IsEqualTo(angle)))
+                    edges.Add((angle, lengthSq));
+            }
+
+            // Longest edges first — they produce the flattest tiling rows.
+            edges.Sort((a, b) => b.lengthSq.CompareTo(a.lengthSq));
+
+            var angles = new List<double>(edges.Count + 1) { 0 };
+
+            foreach (var (angle, _) in edges)
+            {
+                if (!angles.Any(a => a.IsEqualTo(angle)))
+                    angles.Add(angle);
+            }
+
+            return angles;
+        }
+    }
+}