feat(series): operator-set sparse page numbers + gap blocks (#789 tweak)

Replaces the auto-renumbered 1..N position key with operator-OWNED page
numbers: sparse, gaps allowed, editable, never auto-renumbered. Order follows
the numbers; unnumbered pages sort to the tail. This is the fix for the model
that clobbered hand-set numbers on the flatten — numbers are now data, not a
derived sequence.

- series_service: drop the renumber-on-reorder/remove; order by page_number
  NULLS LAST; new set_page_number(image_id, n|None); list_pages returns `gaps`
  (one entry per missing-number run) + each pending group's parsed `start_page`;
  set_cover renumbers below the current min; place_pending(image_ids, start_page)
  numbers placed pages sequentially from the start (drop junk first → numbers
  line up); add_post stamps the parsed start on staged pages.
- api/tags: POST /series/<id>/pages/number (set one page's number); /pending/
  place takes start_page; removed /reorder.
- frontend: per-card editable number input; one gap block per gap with
  drop-on-edge to assign the adjacent number (middle → type); append drop zone;
  pending tray gets a "from page N" field + "Place from page N".
- tests reworked: sparse numbers + gaps, place-from-start, set-page-number route.

No migration; nothing destructive.

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

backend/app/api/tags.py

@@ -415,15 +415,26 @@ async def series_remove(tag_id: int):
     return jsonify({"removed_count": n})
 
 
-@tags_bp.route("/series/<int:tag_id>/reorder", methods=["POST"])
-async def series_reorder(tag_id: int):
-    body = await request.get_json()
-    ids, err = _parse_bulk_ids(body, max_ids=500)
-    if err:
-        return err
+@tags_bp.route("/series/<int:tag_id>/pages/number", methods=["POST"])
+async def series_set_page_number(tag_id: int):
+    """Set one placed page's number — the operator's value (sparse, gaps
+    allowed); pass page_number: null to leave it unnumbered."""
+    body = await request.get_json() or {}
+    image_id, ierr = _opt_int(body, "image_id")
+    if ierr:
+        return ierr
+    if image_id is None:
+        return jsonify({"error": "image_id required"}), 400
+    if "page_number" not in body:
+        return jsonify({"error": "page_number required (may be null)"}), 400
+    page_number, perr = _opt_int(body, "page_number")
+    if perr:
+        return perr
     async with get_session() as session:
         try:
-            await SeriesService(session).reorder(tag_id, ids)
+            await SeriesService(session).set_page_number(
+                tag_id, image_id, page_number
+            )
         except SeriesError as exc:
             return _series_err(exc)
         await session.commit()
@@ -450,8 +461,9 @@ async def series_cover(tag_id: int):
 
 # ---- chapter dividers (FC-6.x) -------------------------------------------
 # A chapter is a cosmetic divider anchored to the page that begins it; it owns
-# no pages. Page ordering is series-wide (the /reorder endpoint above), so there
-# is no per-chapter reorder/merge/chapter-reorder — those are gone.
+# no pages. Page ordering follows each page's operator-set number (the
+# /pages/number endpoint), so there is no per-chapter reorder/merge — those are
+# gone.
 
 
 @tags_bp.route("/series/<int:tag_id>/chapters", methods=["POST"])
@@ -585,19 +597,19 @@ async def series_add_post(tag_id: int):
 
 @tags_bp.route("/series/<int:tag_id>/pending/place", methods=["POST"])
 async def series_place_pending(tag_id: int):
-    """Move staged (pending) pages into the placed run — before `before_image_id`
-    (a placed page) or appended when omitted (#789 P2)."""
+    """Place staged (pending) pages into the run, numbered sequentially from
+    `start_page` in the given order (#789). start_page null → unnumbered."""
     body = await request.get_json()
     ids, err = _parse_bulk_ids(body, max_ids=500)
     if err:
         return err
-    before, berr = _opt_int(body, "before_image_id")
-    if berr:
-        return berr
+    start, serr = _opt_int(body, "start_page")
+    if serr:
+        return serr
     async with get_session() as session:
         try:
             n = await SeriesService(session).place_pending(
-                tag_id, ids, before_image_id=before
+                tag_id, ids, start_page=start
             )
         except SeriesError as exc:
             return _series_err(exc)