fix: recount a hunk header the model miscounted, rather than discarding it

[thedancingdeveloper]

Closes #142.

What was actually wrong

The implementer produced this — complete, correct, applies-in-spirit:

@@ -1,10 +1,21 @@
-from calc import add, subtract
+import pytest
+
+from calc import add, divide, subtract
 ...
+def test_divide_by_zero():
+    with pytest.raises(ZeroDivisionError, match="cannot divide by zero"):
+        divide(1, 0)

test_calc.py has 9 lines; the header declares 10. The body supplies 9
old / 20 new against a declared 10 / 21 — one too many on each side, because
the model counted the trailing newline. The patch is 38 lines and git reports
corrupt patch at line 39: it parsed by the declared counts and ran out of
input.

No rung rescued it. --unidiff-zero fails identically to strict git apply —
tolerance needs something to be tolerant with, and the parser has already hit
EOF. So a correct body was discarded over arithmetic, costing the planner call,
the implementer call, and an attempt.

Four consecutive runs, two different models. A common model error.

The fix, and why it is safe

Recompute the counts from the body. They are a derivable property of it, so
this guesses at nothing — which is precisely what separates it from #133, where
a -0,0 header carried the only statement about where the lines belonged and
there was nothing to recompute. Refused there; repaired here.

Recounting runs as a second variant of each rung, after the patch as written,
so a well-formed diff is still applied byte-for-byte as the model produced it.

Telling two faults apart

They wore one symptom. The rule is principled rather than a threshold:

• over-counted context — a context line counts on both sides, so the
  shortfall is equal on each. Body complete. Recountable.
• cut off mid-hunk — loses a mix of +, - and context, so the shortfalls
  differ. Recounting would make the header agree with a partial body and
  apply, say, a deletion whose replacement never arrived. Stays fatal.

The existing TRUNCATED_DIFF fixture is exactly that dangerous shape and is
still refused — its test now asserts the distinction rather than the wording.

Also: the diagnostic lied

It said the reply was truncated for a reply that was complete at 266 output
tokens. That sent me looking for a token limit that did not exist, and I filed
#142 against the wrong cause before reading the preserved patch. It now states
what is true: how many lines short, on which side.

Result

The backlog that failed 2/3 on four consecutive runs now completes 3/3, one
item via git apply (recounted). Tests pass independently on each branch (4, 4
and 6). Suite, ruff and mypy . green.