Only report the particle fork when the chain actually claims something

Third instance of the same mistake in this emitter, and the same root
cause both previous times: keyed on a SHAPE rather than the DECISION.

When the piece after an ambiguous particle is a suffix, the chain's
inner scan never advances, so merge(k, k+1) folds a piece into itself.
Nothing is chained and the particle stays a lone leading piece -- but
the record was appended before the merge, keyed only on "is a prefix"
plus the ambiguous tag. Result:

    'Dr. Van Jr.'  -> given='Van'  AMB "'Van' was chained into the
                                        family name"

The detail asserted the opposite of what happened, for all 39
particles_ambiguous members. For do/freiherr/st the token lands in the
TITLE instead.

Worse, the no-op leaves exactly the shape _assign triggers on, so 36 of
39 double-reported the same token from two stages.

`j > k + 1` is the discriminator -- it distinguishes a chain that
claimed a following piece from one that claimed nothing -- and it fixes
both defects, since the no-op was the only overlap between the two
emitters' domains. They now partition cleanly.

Also fixed the detail's wording. _group runs before assignment, so it
cannot know which field the chained piece lands in: "Dr. Van Johnson de
la Cruz" puts it in GIVEN, not family. This is the same defect the
role-readback cured in _assign one commit earlier -- the lesson did not
carry to the new emitter, and _group cannot read a role back, so the
text now describes the decision rather than guessing an outcome.

A "Dr. Van Jr." case row would have caught both criticals; 1539 tests
passed with them present because the only titled-particle test used an
UNAMBIGUOUS particle, pinning vocabulary instead of the decision.

Verified: 0 spurious reports across all 39 ambiguous particles; corpus
486 names, 2 intentional diffs, 0 unexplained.

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

Author: derek73

nameparser/_pipeline/_group.py

@@ -174,7 +174,14 @@ def merge(lo: int, hi: int, add: Set[str] = frozenset(),
                 j += 1
             while j < len(pieces) and not prefix(j) and not suffix(j):
                 j += 1
-            if (all(title(x) for x in range(k))
+            # j > k + 1 is what makes this a DECISION rather than a
+            # shape: when the next piece is a suffix the inner scan
+            # never advances, merge(k, k+1) folds a piece into itself,
+            # and the particle stays a lone leading piece -- nothing
+            # was chained, and _assign reports that case instead.
+            # Without this the two emitters both fire on the same token.
+            if (j > k + 1
+                    and all(title(x) for x in range(k))
                     and "vocab:particle-ambiguous"
                     in tokens[pieces[k][0]].tags):
                 particle_forks.append(pieces[k][0])
@@ -295,8 +302,9 @@ def group(state: ParseState) -> ParseState:
             for i in particle_forks:
                 ambiguities.append(PendingAmbiguity(
                     AmbiguityKind.PARTICLE_OR_GIVEN,
-                    f"{tokens[i].text!r} was chained into the family "
-                    f"name; it is also a given name in other names",
+                    f"{tokens[i].text!r} was chained onto the following "
+                    f"name piece; it is also a given name in other "
+                    f"names",
                     (i,)))
     return dataclasses.replace(
         state, tokens=tuple(tokens), pieces=tuple(all_pieces),

tests/v2/cases.py

@@ -115,6 +115,13 @@ def __post_init__(self) -> None:
                "shifts Van off the given position, the prefix chain "
                "fires, and the fork is reported from group rather than "
                "assign (v1 parity on the fields)"),
+    Case("titled_ambiguous_particle_no_op_chain", "Dr. Van Jr.",
+         {"title": "Dr.", "given": "Van", "suffix": "Jr."},
+         notes="the piece after the particle is a suffix, so the chain "
+               "scan never advances and the merge is a no-op -- nothing "
+               "was chained, so there is no fork to report (the emitter "
+               "fired here for all 39 ambiguous particles, and _assign "
+               "double-reported the same token)"),
     Case("initial_shaped_not_conjunction", "john e. smith",
          {"given": "john", "middle": "e.", "family": "smith"},
          notes="v1 is_conjunction excludes initials at classify too"),

tests/v2/test_parser.py

@@ -271,3 +271,30 @@ def test_ambiguous_particle_reports_both_branches_of_its_fork() -> None:
 def test_unambiguous_particle_chain_reports_nothing() -> None:
     # 'de' is never a given name, so merging it is not a fork
     assert parse("Dr. de la Vega").ambiguities == ()
+
+
+@pytest.mark.parametrize("text", [
+    "Dr. Van Jr.",      # the piece after the particle is a suffix, so
+    "Dr. Van MD",       # the chain scan never advances and merge() is
+    "Dr. Do Jr.",       # a no-op -- nothing was chained, no fork taken
+])
+def test_no_op_prefix_chain_is_not_a_fork(text: str) -> None:
+    assert parse(text).ambiguities == ()
+
+
+def test_a_fork_is_reported_by_exactly_one_stage() -> None:
+    # the no-op merge left the particle a lone leading piece, which is
+    # _assign's trigger, so both stages reported the same token
+    n = parse("Dr. Van Jr Smith")
+    assert n.given == "Van"
+    assert len(n.ambiguities) == 1
+
+
+def test_chained_particle_detail_does_not_claim_a_role() -> None:
+    # _group runs before assignment, so it cannot know which field the
+    # chained piece lands in -- "Dr. Van Johnson de la Cruz" puts it in
+    # GIVEN. The detail must describe the decision, not guess a role.
+    n = parse("Dr. Van Johnson de la Cruz")
+    assert n.given == "Van Johnson"
+    (amb,) = n.ambiguities
+    assert "family name" not in amb.detail