Report unmatched closing delimiters too

AmbiguityKind.UNBALANCED_DELIMITER has always documented itself as "a
delimiter opened without closing (or closed without opening)", but only
the first half existed. The scan is opener-driven -- it finds an open
and looks rightward for its close -- so a close with nothing to its
left was never in the search space:

    'Jon "Nick Smith'  -> unbalanced-delimiter
    'John Smith)'      -> (nothing)

No design reason, just the direction of the walk. Both signal the same
malformed input.

Sweep for boundary-valid closes that no match consumed, reusing
_close_ok -- which is what keeps apostrophes out of it. Verified on the
486-name corpus: "O'connor", "O'B.", "Queen's" all have close_ok=False
because the apostrophe is mid-word, so none of them fire.

Offsets already reported as unmatched OPENS are skipped, so a symmetric
delimiter that satisfies both boundary tests still yields exactly one
ambiguity ('John " Smith').

One corpus name newly reports: "Mari' Aube'", two word-final
apostrophes. That is arguably correct -- a trailing apostrophe really
is ambiguous between punctuation and a closing quote -- and the
ambiguity is advisory, so the parse is unchanged (given "Mari'", family
"Aube'"). Worth knowing it will be commoner on transliterated
Arabic/Hebrew/Slavic data, where word-final apostrophes are ordinary.

Found by auditing the existing emitters against the decision-site rule
documented in the previous commit.

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

Author: derek73

nameparser/_pipeline/_extract.py

@@ -174,9 +174,30 @@ def extract_delimited(state: ParseState) -> ParseState:
     # An unmatched-open candidate whose character was consumed by a
     # later successful match (the bulk pass above runs ahead of the
     # main scan) is literal content there, not a dangling delimiter.
-    ambiguities = tuple(
+    reported = {offset for offset, _ in unbalanced}
+    ambiguities = [
         a for offset, a in unbalanced
-        if not _overlaps(Span(offset, offset + 1), masked))
+        if not _overlaps(Span(offset, offset + 1), masked)]
+    # The scan above is opener-driven: it searches for an open and then
+    # looks rightward for its close, so a close with no open to its
+    # LEFT is never in its search space. Sweep for those separately --
+    # they signal the same malformed input, and the kind's contract has
+    # always covered them ("opened without closing, or closed without
+    # opening"). Same boundary test as the matched path, which is what
+    # keeps the apostrophe in "O'connor" out of it.
+    for _, open_, close in order:
+        start = 0
+        while (j := text.find(close, start)) != -1:
+            start = j + 1
+            if (j in reported                      # already an open
+                    or not _close_ok(text, j, len(close))
+                    or _overlaps(Span(j, j + len(close)), masked)):
+                continue
+            reported.add(j)
+            ambiguities.append(PendingAmbiguity(
+                AmbiguityKind.UNBALANCED_DELIMITER,
+                f"unmatched {close!r} at offset {j}; treated as "
+                f"literal text"))
     return dataclasses.replace(
         state, extracted=tuple(extracted), masked=tuple(masked),
-        ambiguities=state.ambiguities + ambiguities)
+        ambiguities=state.ambiguities + tuple(ambiguities))

tests/v2/pipeline/test_extract.py

@@ -1,5 +1,8 @@
 import dataclasses
 
+import pytest
+
+from nameparser import parse
 from nameparser._lexicon import Lexicon
 from nameparser._pipeline._extract import extract_delimited
 from nameparser._pipeline._state import ParseState
@@ -179,3 +182,37 @@ def test_nested_delimiters_inner_scan_order_pins() -> None:
     # flow into the extracted span verbatim -- v1 parity, deliberate
     out = extract_delimited(_state('John ("Jack") Kim'))
     assert out.extracted == ((Role.NICKNAME, Span(6, 12)),)
+
+
+@pytest.mark.parametrize(("text", "char"), [
+    ("John Smith)", ")"),
+    ("John Jack) Smith", ")"),
+    ('John Smith"', '"'),
+    ("John Smith」", "」"),          # a #273 typographic pair
+])
+def test_unmatched_close_is_reported(text: str, char: str) -> None:
+    # the scan is opener-driven, so a close with no open to its left was
+    # never in its search space and went unreported -- even though the
+    # AmbiguityKind docstring promises "or closed without opening"
+    kinds = [a.kind for a in parse(text).ambiguities]
+    assert kinds == [AmbiguityKind.UNBALANCED_DELIMITER]
+    assert char in parse(text).ambiguities[0].detail
+
+
+@pytest.mark.parametrize("text", [
+    "Brian O'connor",       # apostrophe mid-word, not a delimiter
+    "O'B. John Smith",
+    "The Queen's Bench",
+    "John (Jack) Smith",    # matched pair
+    'John "Jack" Smith',
+])
+def test_no_spurious_unmatched_close(text: str) -> None:
+    assert [a for a in parse(text).ambiguities
+            if a.kind is AmbiguityKind.UNBALANCED_DELIMITER] == []
+
+
+def test_unmatched_open_is_not_double_reported_as_a_close() -> None:
+    # a symmetric delimiter can satisfy both boundary tests; it must
+    # still produce exactly one ambiguity
+    assert len(parse('John " Smith').ambiguities) == 1
+    assert len(parse('Jon "Nick Smith').ambiguities) == 1