feat(common-line): place parts on common lines automatically at a chosen level

Slice 3 of common-line cutting. On costly plate (N26-295: 3/16 RA310S at about
$2,500 a sheet) pairing parts one kerf apart fits the part the spacing cannot:
the last plate's 38 parts fit on one 48x120 with Auto Nest only with pairs.

- Drawing Properties gains "Allow common line" (Drawing.AllowCommonLine, off by
  default because customer edge-quality needs vary). The nest's CommonLineUsage
  (Off / When it adds parts / Whenever available) is set in Auto Nest and seeded
  from Tools > Nest Defaults; both persist (nest.json, defaults.json).
- NestPipeline runs the ordinary solve, then, with a level on, trials where
  eligible parts are offered as kerf-gap pair compounds. Placed pairs expand into
  parts plus explicit NestJobCommonLine groups, are validated again, and
  CommonLineRanking keeps a trial only by the level: count first, then sheets;
  "when it adds parts" keeps the plain layout on a tie, "whenever" also takes a
  shorter cut or less material, never at the cost of a part. Engines, FillScore
  and their comparers are unchanged; Off asks the engine exactly what it did.
- NestLayoutCheck exempts members only through a sheet's explicit group list and
  only when the job allows common lines; materializing and committing create
  Plate.CommonLines.
- Server nesting writes common-line jobs as version 3 and replays the recorded
  trial answers, so the desktop binds the same groups.
- Fill Area honors the level through a PlateFillService overload.
- The benchmark gains --common-lines <level> --kerf <k>.

Benchmark (synthetic nests + N26-295, --parallel 1): with no flag and with
--common-lines off every engine matches the base commit; with a level on no
layout becomes invalid and three runs save a sheet at equal nested area.

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

OpenNest.Benchmark/Program.cs

@@ -128,7 +128,8 @@ static class BenchmarkConsole
             options.OutputDirectory,
             options.Parallel,
             options.Progress ? Console.Out : null,
-            options.TimeLimit
+            options.TimeLimit,
+            options.CommonLines
         );
 
         Report.PrintDetailed(results);
@@ -217,6 +218,15 @@ static class BenchmarkConsole
                     o.Progress = true;
                     break;
 
+                case "--common-lines" when i + 1 < args.Length:
+                    o.CommonLineLevel = args[++i];
+                    break;
+
+                case "--kerf" when i + 1 < args.Length:
+                    o.Kerf = double.TryParse(args[++i], System.Globalization.NumberStyles.Float,
+                        System.Globalization.CultureInfo.InvariantCulture, out var kerf) ? kerf : double.NaN;
+                    break;
+
                 case "--help":
                     PrintUsage();
                     return null;
@@ -228,6 +238,25 @@ static class BenchmarkConsole
             }
         }
 
+        if (o.CommonLineLevel != null)
+        {
+            CommonLineUsage? usage = o.CommonLineLevel.ToLowerInvariant() switch
+            {
+                "off" => CommonLineUsage.Off,
+                "when-it-adds-parts" => CommonLineUsage.WhenItAddsParts,
+                "whenever" => CommonLineUsage.Whenever,
+                _ => null,
+            };
+            if (usage == null || o.Kerf is not { } kerf || !double.IsFinite(kerf) || kerf <= 0)
+            {
+                Console.Error.WriteLine(
+                    "Error: --common-lines needs off, when-it-adds-parts or whenever, and a positive --kerf"
+                );
+                o.Invalid = true;
+            }
+            else
+                o.CommonLines = new CommonLineSetting(usage.Value, kerf);
+        }
         return o;
     }
 
@@ -368,6 +397,18 @@ static class BenchmarkConsole
         Console.Error.WriteLine(
             "                                 the best valid plan reported; none = timed out"
         );
+        Console.Error.WriteLine(
+            "  --common-lines <level>          Solve through the Auto Nest pipeline with every part allowed"
+        );
+        Console.Error.WriteLine(
+            "                                 to share a common line: off, when-it-adds-parts or whenever"
+        );
+        Console.Error.WriteLine(
+            "                                 (needs --kerf; off is the baseline to compare levels with)"
+        );
+        Console.Error.WriteLine(
+            "  --kerf <value>                  Common-line kerf in job units (with --common-lines)"
+        );
         Console.Error.WriteLine("  --help                          Show this message");
     }
 
@@ -384,6 +425,9 @@ static class BenchmarkConsole
         public int Parallel = 3;
         public bool Progress;
         public TimeSpan? TimeLimit;
+        public string CommonLineLevel;
+        public double? Kerf;
+        public CommonLineSetting CommonLines;
         public bool Invalid;
     }
 }