refactor(schedule10): split document assembly out of Schedule10Service

Clears the last two SonarCloud findings on PR #305.

USE containsEntry (Minor). One assertion was left on the old shape by the earlier
mechanical pass, because it spanned lines and carried an .as(...) description.
Converted, and folded together with the assertion below it so the pair cannot
return as a "join assertions" flag.

MONSTER CLASS (21 dependencies against a limit of 20). Sonar's suggested fix was
to split the class, and that is what this does rather than trimming one incidental
dependency to get under the threshold. Schedule10Service had grown to 1137 lines
doing two genuinely separate jobs, and the seam between them was clean: nothing in
the assembly touches a request DTO, and nothing in the write path touches a
response DTO beyond returning one.

  Schedule10Service            1137 -> 786 lines   the seven writes, validation,
                                                   Check Status entry point
  Schedule10DocumentAssembler   378 lines (new)    assembly and read-side derivation
  Schedule10CostItems            52 lines (new)    the 12 cost-item ordinals and 3
                                                   column scales BOTH halves need

Service imports fall from 38 to 23 -- fifteen became unused the moment the
assembly left, which is precisely the coupling Sonar was measuring.
Schedule10CostItems exists because the ordinals and scales are genuinely shared;
the alternatives were declaring the same twelve magic numbers twice, or having the
assembler reach back into the service.

This also closes a separate code-review finding at no extra cost. The write paths
previously read the track status TWICE -- once for requireDraft's gate, then again
inside assembly to compute editable. The service now reads it once and passes both
the status and the derived editability to the assembler, so there is one read per
request. Safe to change: the service test uses lenient mocks with no call-count
verification.

The assembler is constructed by the service rather than injected as a bean. It is
an implementation detail with no independent lifecycle, and constructing it keeps
the existing single-argument constructor every test already uses, so no test
wiring changed.

Verification: 1151 unit + 881 integration tests, 0 failures; 0 checkstyle
violations in schedule10. Schedule10DocumentIT -- which asserts the assembled
document byte-for-byte against the pinned contract, and covers the code that
moved -- passes unchanged, which is the evidence that the extraction preserved
behaviour.

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

Author: Rylan-cgi

backend/src/main/java/ca/bc/gov/nrs/ilcr/schedule10/Schedule10CostItems.java

@@ -0,0 +1,53 @@
+package ca.bc.gov.nrs.ilcr.schedule10;
+
+import java.util.Set;
+
+/**
+ * The legacy cost-item ordinals Schedule 10 routes, and the column scales its dimensions are stored
+ * at.
+ *
+ * <p>Held here because BOTH halves of the schedule need them: the read path routes stored cost rows
+ * into the document's substructures by ordinal, and the write path writes the same twelve rows
+ * back. They lived on {@code Schedule10Service} until the document assembly was extracted (code
+ * review follow-up 2026-08-19) — at which point keeping them there would have meant either a
+ * back-reference from the assembler to the service, or the same twelve magic numbers declared
+ * twice.
+ */
+final class Schedule10CostItems {
+
+  // Legacy cost-item ordinals (Constant.REPORT_COST_ITEMS :371-376), all verified against the
+  // delivery ILCR_REPORT_COST_ITEM rows. The six "Less" lines span THREE subcategories, so routing
+  // must be by item id — scanning a single subcategory would silently under-count the deductions.
+  static final int SUB_GRADE_TRANSFER = 3;        // cat 10 / sub 1
+  static final int LESS_OTHER_ENGINEERING = 4;    // cat 10 / sub 3
+  static final int OTHER_TT_TRANSFER = 5;         // cat 10 / sub 3
+  static final int LESS_CULVERT = 6;              // cat 10 / sub 1
+  static final int LESS_BRIDGE = 7;               // cat 10 / sub 1
+  static final int LESS_LANDING = 8;              // cat 10 / sub 1
+  static final int STABILIZING_OTHER_TRANSFER = 9; // cat 10 / sub 4
+  static final int STABILIZING_TRANSFER = 10;     // cat 10 / sub 2
+  static final int LESS_OVERLAND = 11;            // cat 10 / sub 1
+  static final int SUB_GRADE_ACTUAL = 20;         // cat 10 / sub 1
+  static final int LESS_END_HAUL = 21;            // cat 10 / sub 1
+  static final int STABILIZING_ACTUAL = 22;       // cat 10 / sub 2
+
+  /**
+   * Every cost-item ordinal Schedule 10 routes. A cost row outside this set contributes to no
+   * substructure and would silently vanish from the totals, so it is logged instead.
+   */
+  static final Set<Integer> ROUTED = Set.of(
+      SUB_GRADE_TRANSFER, LESS_OTHER_ENGINEERING, OTHER_TT_TRANSFER, LESS_CULVERT, LESS_BRIDGE,
+      LESS_LANDING, STABILIZING_OTHER_TRANSFER, STABILIZING_TRANSFER, LESS_OVERLAND,
+      SUB_GRADE_ACTUAL, LESS_END_HAUL, STABILIZING_ACTUAL);
+
+  // G8 — Oracle does not preserve trailing zeros, so a NUMBER(6,3) holding 3.000 comes back as 3
+  // and serialises as the integer 3 while its 12.500 neighbour serialises as 12.5. Stored
+  // dimensions are normalised to their column's declared scale so the served document matches the
+  // pinned contract regardless of the value (code review 2026-08-17 — caught by a new assertion).
+  static final int LENGTH_SCALE = 3;   // SUB_GRADE_LENGTH / STABILIZING_LENGTH  NUMBER(6,3)
+  static final int MEASURE_SCALE = 1;  // widths, depth, distances               NUMBER(x,1)
+  static final int VOLUME_SCALE = 0;   // END_HAUL_VOLUME / OVERLAND_VOLUME      NUMBER(7,0)
+
+  private Schedule10CostItems() {
+  }
+}