Rework OpenNest.Benchmark into a full multi-plate, multi-size nest

Previously each job fixed one plate size and ran a single Nest() call,
which doesn't reflect the actual problem: a real job is fulfilled
across however many plates are needed, drawn from a pool of standard
sheet sizes, not forced onto one fixed sheet.

NestEngineBase.Nest() has no way to pick its own plate's size - it
fills whatever Plate it's given - so size selection now lives in the
harness itself, applied identically to every engine:

- BenchmarkJob carries the full candidate size pool (CandidateSizes)
  instead of one fixed PlateSize; one job per file, not one per size.
- BenchmarkRunner drives a loop: while items remain, pick the smallest
  candidate size that fits the largest still-unplaced drawing (reusing
  the codebase's own MultiPlateNester.CreatePlate/FitsBounds), build a
  fresh plate of that size, and run one Nest() call to fill it. Repeat
  until everything is placed, no candidate size fits what's left, or a
  safety cap (40 plates) is hit.
- NestValidator now validates bounds/spacing per plate but the
  quantity cap once globally across all plates, since that limit
  belongs to the whole order, not any one sheet.
- JobResult/Report report PlatesUsed and a per-size breakdown instead
  of a single-plate bounding-box compactness metric; utilization is
  now aggregated across every plate the engine used. Ranking keeps the
  same rule (utilization first), with fewer plates as the tie-break
  when both are fully placed and tied - the natural multi-plate
  analogue of the old single-plate compactness tie-break.

Smoke-tested against the synthetic sample across 5 candidate sizes:
correctly builds one job, picks the smallest fitting size, uses
however many plates each engine needs (1-2 here), and still catches
StripNestEngine's pre-existing out-of-bounds bug.

OpenNest.Benchmark/JobResult.cs

@@ -3,8 +3,11 @@ using System.Collections.Generic;
 namespace OpenNest.Benchmark
 {
     /// <summary>
-    /// Outcome of running one engine against one job. An invalid or crashed run
-    /// always scores zero utilization for that job, per the benchmark rules.
+    /// Outcome of running one engine against one job. A job may span several
+    /// plates (PlatesUsed, SizeBreakdown), since the engine may need more than
+    /// one sheet - possibly of different sizes - to place everything asked of
+    /// it. An invalid or crashed run always scores zero utilization, per the
+    /// benchmark rules.
     /// </summary>
     public class JobResult
     {
@@ -17,11 +20,16 @@ namespace OpenNest.Benchmark
         public int PartsRequested { get; init; }
         public double PlacedArea { get; init; }
         public double PlateArea { get; init; }
-        public double UsedBoundingBoxArea { get; init; }
+        public int PlatesUsed { get; init; }
+        public Dictionary<string, int> SizeBreakdown { get; init; } = new();
         public long ElapsedMs { get; init; }
 
         public bool Crashed => Error != null;
         public bool FullyPlaced => Valid && PartsRequested > 0 && PartsPlaced >= PartsRequested;
+
+        /// <summary>Aggregate utilization across every plate the engine used:
+        /// total placed drawing area over total plate area, matching
+        /// Plate.Utilization()'s per-plate definition summed across the job.</summary>
         public double Utilization => Valid && PlateArea > 0 ? PlacedArea / PlateArea : 0;
     }
 }