Guard against complexity regressions, not just slow parses

Two quadratics shipped this cycle (_extract's mask-overlap scan,
ParsedName's token-subset check) and both were caught in review rather
than by a test. The existing perf tests cannot catch that class: they
bound absolute cost on constant-size input, and their workload is a
short name with no delimiters, so a stage quadratic in the number of
delimiter pairs stays far inside the one-second bound. Measured: that
workload runs in 0.067s against a 1.0s limit.

Add a growth test instead -- time a repeated pathological unit at n and
4n, assert the ratio stays near the linear 4. Seven units, one per
stage inner loop (matched pairs, the open==close path, both unmatched
sweeps, long token streams, comma segments, title chains).

Calibrated against the real quadratic rather than guessed, which
mattered: the growth is mixed, so the textbook 16x never appears at a
testable size. At n=200 the quadratic measures 7.7x and an 8.0 bound
passes it -- the first version of this test was vacuous. At n=400 the
populations separate (clean 4.1-4.3, quadratic 9.2), so the bound sits
at 6.5. Verified both ways: passes clean, and reverting the _extract
fix fails exactly the two shapes that build masked spans.

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

Author: derek73

tests/v2/test_benchmark.py

@@ -1,8 +1,21 @@
 """Perf smoke (core spec §7 tail): parse cost stays v1-comparable
 (microseconds per name). Deliberately generous bound -- guards against
-order-of-magnitude regressions, does not gate normal variance."""
+order-of-magnitude regressions, does not gate normal variance.
+
+Two different things are measured here, and the distinction matters.
+The thousand-names tests below bound ABSOLUTE cost on constant-size
+input; the scaling test bounds GROWTH in input length. Neither
+subsumes the other, and the absolute tests are structurally blind to a
+complexity regression: their workload is a short name with no
+delimiters, so a stage that goes quadratic in the number of delimiter
+pairs stays far inside the one-second bound. Two such quadratics
+(_extract's mask-overlap scan, ParsedName's token-subset check) shipped
+and were caught in review rather than here -- hence the scaling test.
+"""
 import time
 
+import pytest
+
 from nameparser import parse
 
 
@@ -26,3 +39,58 @@ def test_facade_thousand_names_under_a_second() -> None:
         HumanName(f"Dr. Juan{i} de la Vega III")
     elapsed = time.perf_counter() - start
     assert elapsed < 1.0, f"1000 facade parses took {elapsed:.2f}s"
+
+
+# Pathological shapes: each repeats a unit that drives one stage's inner
+# loop. Cheap per unit, so a superlinear stage shows up as growth rather
+# than as a slow parse.
+_SHAPES = {
+    "delimiter_pairs": "(a) ",      # extract: matched pairs -> masked spans
+    "quote_pairs": '"a" ',          # extract: the open==close path
+    "unmatched_opens": "( ",        # extract: the bulk unmatched-open sweep
+    "unmatched_closes": ") ",       # extract: the unmatched-close sweep
+    "plain_tokens": "a ",           # tokenize/assign: long token stream
+    "commas": "a, ",                # segment: many comma segments
+    "titles": "Dr. ",               # group: one long title chain
+}
+
+_BASE = 400
+_FACTOR = 4
+# Calibrated, not guessed. A quadratic here is MIXED -- linear work
+# dominates at small sizes and the quadratic term takes over slowly --
+# so the textbook 16x never appears at a testable size, and picking the
+# operating point matters more than the bound. Measured against the
+# real _extract mask-overlap quadratic this test exists to catch:
+#
+#   base    clean ratio    quadratic ratio
+#    200      3.9 - 4.3          7.7        <- under an 8.0 bound: useless
+#    400      4.1 - 4.3          9.2
+#
+# At 400 the two populations separate, so the bound sits between them:
+# ~1.5x headroom over the worst clean run (noise on a shared runner)
+# and ~1.4x under the quadratic. Lower this only with fresh numbers.
+_MAX_RATIO = 6.5
+
+
+def _best(text: str, repeats: int = 7) -> float:
+    """Minimum of several runs: on a shared runner the mean carries the
+    noise of whatever else is running, while the minimum approaches the
+    true cost."""
+    parse(text)                     # warm the default parser cache
+    best = float("inf")
+    for _ in range(repeats):
+        start = time.perf_counter()
+        parse(text)
+        best = min(best, time.perf_counter() - start)
+    return best
+
+
+@pytest.mark.parametrize("unit", _SHAPES.values(), ids=list(_SHAPES))
+def test_parse_cost_grows_no_worse_than_linearly(unit: str) -> None:
+    small = _best(unit * _BASE)
+    large = _best(unit * (_BASE * _FACTOR))
+    ratio = large / small
+    assert ratio < _MAX_RATIO, (
+        f"{unit!r} x{_BASE} took {small * 1e3:.2f}ms, "
+        f"x{_BASE * _FACTOR} took {large * 1e3:.2f}ms -- {ratio:.1f}x for "
+        f"{_FACTOR}x the input, which is superlinear (linear is ~{_FACTOR})")