fix(task-13): read revision/balloon state from the space it is drawn on, and never at 200

Three findings, one family: a guard that reads the WRONG SET silently stops
guarding and the drawing gets a duplicate or a wrong number with no refusal.

1. Layout-scoped state was read from the wrong space. add_revision called
   read_revisions and add_balloon called read_balloons BEFORE enter_layout;
   both read entity_list, which follows the current space, so the guard
   inspected Model while the rows and balloons lived on the layout -- and the
   layout is the sheet workflow (sheet_frame and titleblock_apply both take
   one). Measured headlessly: two revision_add(rev="B", layout="SHEET1") calls
   both returned created=True, handles 46 and 5A, both bbox
   {min [230,273], max [410,287]} -- a second heading band and a second B row
   drawn exactly on top of the first, twelve TEXTs on the tab instead of six.
   Both reads now happen inside the entered layout, and the whole body sits in
   the try/ so the caller's tab comes back on the refusal path too.

2. bom_extract truncated the parts list at 200 INSERTs and printed a wrong QTY
   into a real TABLE. extract_records passed its own limit=200 default straight
   to entity_list, the tool exposed no limit, and nothing in the payload said
   the list had been cut: 250 bolts reported [("ISO 4014 - M12x60", 200)].
   all_entities now pages entity_list (offset loop, PAGE_SIZE 1000, plus a
   no-new-handles guard so a backend that ignored offset cannot spin) and
   extract_records(limit=None) reads the whole drawing. bom_extract exposes
   limit (0 = no cap) and reports truncated measured, by asking for one record
   past the cap.

3. The balloon clash guard did not fire in two routine cases. (a) targets is
   optional in the tool, so the clash test compared () != () -- False -- and
   two untargeted balloons carried item 1 with no refusal. The renumber arm
   above has already returned for the balloon that stands for these targets, so
   anything still carrying the number is a clash, whatever its targets; the
   message names the handle and says "no targets" when it has none. (b)
   read_balloons and read_revisions took entity_list's 200-entity default, so a
   drawing whose first 200 CIRCLEs are a hole pattern read back no balloons at
   all and every guard passed blind -- and index = len(existing) restarted at
   0, stacking revision bands. Both readers now go through all_entities.

Evidence, headless (ezdxf), each finding's own repro before -> after:
  1  created True/True, handles 46+5A, 12 TEXTs -> created True/False, one
     handle 46, 6 TEXTs; renumbered False/False -> False/True, same handle 33
  2  records 200, rows [(..., 200)] -> records 250, rows [(..., 250)]
  3a two balloons handles 2F+35, no refusal -> refused, naming balloon 2F
  3b read_balloons() == () with 206 circles -> the balloon past the 200th
     circle is found, the rerun renumbers, the item-1/BBB clash is refused
  3c 200 notes + rev A twice + rev B -> created True/False/True, row 1 then
     row 2 (was: every band at row 1, on top of the last)

Six regression tests added: one per finding plus the layout-scoped twin of
each, which is what would have caught all three.

The live engine was UNAVAILABLE for this round:
win32com.client.GetActiveObject("AutoCAD.Application") did not return within
90 s against the running acad.exe (PID 40068), and the ComBackend probe timed
out on its first call at both COM_CALL_TIMEOUT=60 and 180. No second AutoCAD
was launched and no document was opened. No new ActiveX call is introduced by
this fix -- it only reorders existing calls and pages entity_list(offset=),
which both engines already implement.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FKFStjEFzpGyLq5bMpWxTd

tests/test_sheet_bom.py

@@ -294,3 +294,96 @@ async def test_reusing_an_item_number_for_different_targets_is_refused(backend):
         await add_balloon(backend, item=1, at=(100.0, 40.0), leader_to=(60.0, 0.0), targets=(two,))
     assert "1" in str(excinfo.value)
     assert len(await backend.entity_list()) == before
+
+
+@pytest.mark.asyncio
+async def test_a_second_balloon_with_the_same_number_and_no_targets_is_refused(backend):
+    """`targets` is optional in the tool, so the clash test used to compare
+    `() != ()` -- False -- and never fire. Two balloons carrying item 1."""
+    first = await add_balloon(backend, item=1, at=(40.0, 40.0), leader_to=(0.0, 0.0))
+    before = len(await backend.entity_list())
+    with pytest.raises(ValueError) as excinfo:
+        await add_balloon(backend, item=1, at=(90.0, 40.0), leader_to=(60.0, 0.0))
+    assert first["handle"] in str(excinfo.value)
+    assert len(await backend.entity_list()) == before
+    assert [b["item"] for b in await read_balloons(backend)] == [1]
+
+
+@pytest.mark.asyncio
+async def test_the_balloon_guards_read_past_the_entity_list_page(backend):
+    """A routine hole pattern fills `entity_list`'s 200-entity default, which
+    used to make `read_balloons` return nothing and every guard pass."""
+    for index in range(200):
+        await backend.entity_create_circle(float(index) * 10.0, 0.0, 2.0)
+    await add_balloon(backend, item=1, at=(40.0, 400.0), leader_to=(0.0, 380.0), targets=("AAA",))
+    assert [b["item"] for b in await read_balloons(backend)] == [1]
+    again = await add_balloon(
+        backend, item=9, at=(40.0, 400.0), leader_to=(0.0, 380.0), targets=("AAA",)
+    )
+    assert again["renumbered"] is True, "the guard must see a balloon past the 200th circle"
+    with pytest.raises(ValueError):
+        await add_balloon(
+            backend, item=9, at=(200.0, 400.0), leader_to=(160.0, 380.0), targets=("BBB",)
+        )
+
+
+@pytest.mark.asyncio
+async def test_extract_reads_every_insert_not_the_first_page(backend):
+    """250 bolts must report QTY 250. The 200-entity `entity_list` default used
+    to print 200 into a real TABLE with nothing saying it had been cut."""
+    await backend.block_define("BOLT", [{"type": "circle", "cx": 0.0, "cy": 0.0, "r": 3.0}], [])
+    for index in range(250):
+        insert = await backend.block_insert("BOLT", float(index) * 10.0, 0.0)
+        await backend.entity_set_xdata(
+            insert.handle,
+            APP_ID,
+            to_values(
+                {
+                    "v": 1,
+                    "kind": "std_part",
+                    "designation": "ISO 4014 - M12x60",
+                    "standard": "ISO 4014",
+                    "size": "M12x60",
+                    "qty": 1,
+                    "material": "8.8",
+                }
+            ),
+        )
+    records = await extract_records(backend)
+    assert len(records) == 250
+    rows = rows_from_records(records)
+    assert [(r["designation"], r["qty"]) for r in rows] == [("ISO 4014 - M12x60", 250)]
+    # A cap is still honoured when one is asked for, explicitly.
+    assert len(await extract_records(backend, limit=17)) == 17
+    with pytest.raises(ValueError):
+        await extract_records(backend, limit=0)
+
+
+@pytest.mark.asyncio
+async def test_the_balloon_guards_read_the_layout_they_draw_on(backend):
+    """`read_balloons` follows the current space, so reading it before
+    `enter_layout` inspected Model while the balloons went on the layout."""
+    await backend.layout_create("SHEET1")
+    first = await add_balloon(
+        backend, item=1, at=(40.0, 40.0), leader_to=(0.0, 0.0), targets=("AAA",), layout="SHEET1"
+    )
+    again = await add_balloon(
+        backend, item=5, at=(40.0, 40.0), leader_to=(0.0, 0.0), targets=("AAA",), layout="SHEET1"
+    )
+    assert again["renumbered"] is True
+    assert again["handle"] == first["handle"]
+    with pytest.raises(ValueError):
+        await add_balloon(
+            backend,
+            item=5,
+            at=(90.0, 40.0),
+            leader_to=(60.0, 0.0),
+            targets=("BBB",),
+            layout="SHEET1",
+        )
+    assert (await backend.layout_list())["current"] == "Model", "the caller's tab must come back"
+    await backend.layout_set_current("SHEET1")
+    try:
+        assert len(await backend.entity_list(type_filter="CIRCLE", limit=10_000)) == 2
+    finally:
+        await backend.layout_set_current("Model")