fix: seven defects an adversarial audit found, and the gates that missed them

Every one of these was reported ok/clean to the caller while being wrong.

Silently wrong numbers
- selection_filter(min_area) read `entity.dxf.get("area", 0.0)` for SOLID,
  TRACE and HATCH, none of which carry that attribute, so every hatch
  measured 0.0. A 1600 mm^2 hatch was excluded by min_area=1.0 while
  `filtered_by` asserted the filter had run, and COM (which reads ActiveX
  .Area) returned a different selection for the same call. It now answers
  from the measurement `entity_measure` uses, so the two cannot disagree.
- Every headless dimension rendered through ezdxf's bare `Standard` style:
  1.0 mm text with a comma decimal marker, against ISO 3098's 2.5 mm minimum
  and ISO 129's point -- while the document header itself said $DIMTXT 2.5.
  `ezdxf.new(setup=True)` is not the fix; measured, it renders a 100 mm
  dimension as "10000". The attributes are now stored explicitly.
- Saving writes `dimrnd = 0.0` onto the Standard style, and ezdxf applies
  `xround(value, dimrnd)` whenever the attribute is present at all --
  `xround(33.333, 0.0)` is 33. So on any reopened file, including one this
  server saved, every dimension was rounded to a whole unit before DIMDEC
  formatted it: a 12.75 mm feature dimensioned 13. AutoCAD means DIMRND 0 as
  *no* rounding; the sentinel is now discarded at every load site, and a real
  0.5 mm rounding is left alone.
- The DIM* header fold gave out-of-range values teeth they did not have when
  they died in the header: dim_decimals=-1 returned ok and then killed the
  next dimension with `ValueError: Format specifier missing precision` from
  inside ezdxf, and 40 printed forty digits of float noise onto the sheet.
  Ranges are now AutoCAD's own (DIMDEC 0-8, DIMZIN 0-15, lengths positive).

Security
- security.py recorded the policy as "sanitize_command and sanitize_lisp each
  have exactly ONE caller ... the policy is scoped to the CHANNEL". The
  premise was false. `_ensure_linetype_loaded` and `ComBackend.linetype_load`
  build `_-LINETYPE _LOAD {name} {file}` and hand it to SendCommand, which
  treats a newline and ';' as segment separators -- so a `linetype=` argument
  carrying either injected further AutoCAD commands, and the 36-verb denylist
  never saw that channel. Guarded with the DXF symbol-name rule (the
  injection characters fall out of it rather than being enumerated) plus
  validate_path for the file argument, which was also the one path-taking
  tool reaching the filesystem unchecked. The policy comment is corrected.

Gates that could not see
- drawing_critique returned zero issues on a quarantined document: all seven
  checks wrapped their backend call in a bare `except Exception`. CLAUDE.md
  rule 7 makes that call the gate an agent is told to trust. Only the
  quarantine now escapes; an ordinary broken check still degrades.
  `_check_dimension_legibility` also read `_doc` directly from the event loop
  thread, missing the gate and performing exactly the unsynchronised access
  the quarantine exists to prevent. `construction_clear` answered
  "deleted: 0" -- there was nothing to clear -- for the same reason.
- The iso128 focus checked layer lineweights only, so a sheet lettered at
  1.0 mm critiqued clean. It now reads the effective dimension height and
  separator, header-then-style, in the order the renderer resolves.
- check_doc_numbers.py derived five values it never checked, and those were
  the ones that had drifted. The collected-test count (README said 1274, the
  tree had 1369) and the A/B pass-rate and Fixed columns are now gated.
- benchmarks/README.md's v1.4.0 table was impossible on its face -- 21
  passing plus 5 fixed is 26, not 24 -- and contradicted the report it
  linked, because `ab-v1.4.0-vs-v1.5.0.json` was regenerated from a tree that
  already carried the dimension fixes and so never measured the v1.5.0 tag.
  Replaced with a real run: ab-v1.4.0-vs-v1.5.1.json, 21/26 -> 26/26.

Release gate
- release.yml ran one ubuntu/3.11 lane, so a Windows-only defect could reach
  PyPI with no Windows job having executed. That is not hypothetical: v1.5.0
  shipped `except pywintypes.com_error` raising NameError wherever pywin32 is
  absent. It now runs the same three lanes as ci.yml, Windows included.

1368 passed, 1 xfailed. ruff clean. Tool inventory and all 16 gated document
numbers match the tree.

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

tests/test_ezdxf_honesty.py

@@ -29,6 +29,7 @@ import pytest
 import config
 from backends.com_backend import ComBackend
 from backends.ezdxf_backend import EzdxfBackend
+from backends.quarantine import DocumentQuarantineError
 
 pytestmark = pytest.mark.asyncio
 
@@ -113,31 +114,45 @@ async def test_both_backends_declare_the_same_capability_keys():
 
 
 async def test_slow_call_times_out_and_backend_stays_usable(backend, monkeypatch):
+    """The anti-deadlock guarantee, restated after R32.
+
+    This used to assert that the next ``drawing_info`` / ``entity_create_line``
+    *succeeded*, on the strength of a ``_hang`` that only slept and touched no
+    document. Both assertions were the defect written down as a requirement: the
+    lock swap that stops the deadlock is exactly what drops mutual exclusion on
+    the one shared ``Drawing``, so "succeeded" meant "ran against a document
+    another thread may still be writing". The guarantee that actually holds is
+    that the next call returns *immediately* — refused, not queued.
+    """
     monkeypatch.setattr(config.settings, "ezdxf_call_timeout", 0.2)
     entered = threading.Event()
+    release = threading.Event()
 
     def _hang():
         entered.set()
-        time.sleep(2.0)
+        release.wait(5.0)
         return "too late"
 
-    started = time.monotonic()
-    with pytest.raises(RuntimeError) as excinfo:
-        await backend._async(_hang)
-    assert entered.is_set()
-    assert time.monotonic() - started < 1.5, "must abandon the call, not wait it out"
+    try:
+        started = time.monotonic()
+        with pytest.raises(RuntimeError) as excinfo:
+            await backend._async(_hang)
+        assert entered.is_set()
+        assert time.monotonic() - started < 1.5, "must abandon the call, not wait it out"
 
-    message = str(excinfo.value)
-    assert "EZDXF_CALL_TIMEOUT" in message
-    assert "0.2" in message
+        message = str(excinfo.value)
+        assert "EZDXF_CALL_TIMEOUT" in message
+        assert "0.2" in message
 
-    # The anti-deadlock guarantee: the NEXT call must not queue behind the
-    # abandoned worker thread (which is still sleeping).
-    monkeypatch.setattr(config.settings, "ezdxf_call_timeout", 10)
-    info = await asyncio.wait_for(backend.drawing_info(), timeout=3)
-    assert info.backend == "ezdxf"
-    line = await asyncio.wait_for(backend.entity_create_line(0, 0, 1, 1), timeout=3)
-    assert line.handle
+        monkeypatch.setattr(config.settings, "ezdxf_call_timeout", 10)
+        started = time.monotonic()
+        with pytest.raises(DocumentQuarantineError):
+            await asyncio.wait_for(backend.drawing_info(), timeout=3)
+        with pytest.raises(DocumentQuarantineError):
+            await asyncio.wait_for(backend.entity_create_line(0, 0, 1, 1), timeout=3)
+        assert time.monotonic() - started < 1.0, "refused up front, never queued"
+    finally:
+        release.set()
 
 
 async def test_waiting_on_a_busy_backend_times_out_without_stealing_the_lock(backend, monkeypatch):
@@ -151,6 +166,10 @@ async def test_waiting_on_a_busy_backend_times_out_without_stealing_the_lock(bac
             await backend._async(lambda: "never runs")
         assert time.monotonic() - started < 1.0
         assert backend._lock is live, "the in-flight call's lock must not be swapped out"
+        # R32: nothing was abandoned here, so nothing may be quarantined — that
+        # lock is held by a live call which will release it normally.
+        assert backend._quarantine is None
+        assert backend._abandoned_calls == []
     finally:
         live.release()
 
@@ -166,6 +185,10 @@ async def test_zero_timeout_disables_the_check(backend, monkeypatch):
         return "finished"
 
     assert await backend._async(_slow) == "finished"
+    # R32: with the deadline off there is no abandon branch at all, so there is
+    # nothing that could quarantine the document.
+    assert backend._quarantine is None
+    assert backend._abandoned_calls == []
 
 
 async def test_async_still_serialises_calls(backend):
@@ -202,6 +225,9 @@ async def test_a_call_raising_TimeoutError_is_not_reported_as_the_deadline(backe
         await backend._async(_boom)
 
     assert backend._lock is live, "a call that merely failed must not abandon its lock"
+    # R32: not our deadline, so no thread was abandoned and the document is fine.
+    assert backend._quarantine is None
+    assert backend._abandoned_calls == []
     assert await asyncio.wait_for(backend._async(lambda: "next"), timeout=2) == "next"