Pin the four hand-copied patterns the sync roster never listed

The M11 orphan sweep turned up not dead code but an unenforced promise.
_render's _SPACES, _SPACE_BEFORE_COMMA, _MAC and _WORD are hand-copies
of nameparser.config.regexes keys, and test_regex_sync.py -- whose
docstring says "nothing previously enforced that promise" -- covered
eleven such copies and not these four. They had not diverged; nothing
would have reported it if they had.

They went unnoticed because the config keys lost their only other
reader when M11 deleted v1's parser.py (space_before_comma was
parser.py:305), so the config side looks unused and the render side
looks self-contained. Same shape as regexes.no_vowels (#268) and
util.py's orphans, except here the pattern is still needed -- it just
has two definitions and no link between them.

Declared as a roster with a completeness check rather than one test per
copy: the roster grew one test at a time, which is exactly how four
copies were left out. A compiled pattern in those modules that is not
declared -- with its config key, or None for the ones pinned by
relationship (the _INITIAL pair) or sourced elsewhere (_COMMA_CHAR
mirrors _state.COMMA_CHARS) -- now fails. Verified both directions:
an undeclared new pattern fails the completeness check, and editing
_SPACE_BEFORE_COMMA fails its sync assertion.

Also pins _COMMA_CHAR against COMMA_CHARS, which had no test at all.

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

Author: derek73

tests/v2/test_regex_sync.py

@@ -9,6 +9,10 @@
 CI signal. Tests may legally import both sides (test_layering.py's own
 convention), so this module is where the promise gets checked.
 """
+import re
+
+import pytest
+
 from nameparser.config import regexes as _config
 from nameparser._pipeline import _assign, _post_rules, _tokenize, _vocab
 from nameparser import _render
@@ -71,3 +75,77 @@ def test_initial_copies_agree_with_each_other_and_config() -> None:
     reconstructed = trimmed[:-1] + "?" + trimmed[-1:]
     assert source.pattern == reconstructed
     assert source.flags == _vocab._INITIAL.flags
+
+
+# The roster above grew one test at a time, and four hand-copies were
+# never added to it -- _render's _SPACES, _SPACE_BEFORE_COMMA, _MAC and
+# _WORD. They had not diverged, but nothing would have said so, which
+# is the exact promise this module exists to keep. All four mirror a
+# config key whose only other reader was v1's parser.py, deleted at the
+# M11 swap, so nothing else touches them either.
+#
+# Declared as a roster rather than one test per copy, with a
+# completeness check below: adding a pattern without declaring its
+# source now fails here instead of being silently unpinned.
+_SOURCES: dict[tuple[str, str], str | None] = {
+    ("_assign", "_PERIOD_ABBREV"): "period_abbreviation",
+    ("_assign", "_ROMAN"): "roman_numeral",
+    ("_post_rules", "_EAST_SLAVIC"): "east_slavic_patronymic",
+    ("_post_rules", "_EAST_SLAVIC_CYR"): "east_slavic_patronymic_cyrillic",
+    ("_post_rules", "_TURKIC"): "turkic_patronymic_marker",
+    ("_post_rules", "_TURKIC_CYR"): "turkic_patronymic_marker_cyrillic",
+    ("_render", "_SPACES"): "spaces",
+    ("_render", "_SPACE_BEFORE_COMMA"): "space_before_comma",
+    ("_render", "_MAC"): "mac",
+    ("_render", "_WORD"): "word",
+    ("_vocab", "_PERIOD_NOT_AT_END"): "period_not_at_end",
+    # Deliberately NOT a straight copy -- pinned by the dedicated tests
+    # above, which assert the documented RELATIONSHIP instead:
+    ("_render", "_INITIAL"): None,      # config's pattern minus one "?"
+    ("_vocab", "_INITIAL"): None,       # same
+    ("_tokenize", "_BIDI"): None,       # re_bidi, not a REGEXES key
+    # Mirrors _pipeline._state.COMMA_CHARS, not nameparser.config
+    ("_render", "_COMMA_CHAR"): None,
+}
+
+_MODULES = {"_assign": _assign, "_post_rules": _post_rules,
+            "_render": _render, "_tokenize": _tokenize, "_vocab": _vocab}
+
+
+@pytest.mark.parametrize(
+    "where,key", [(w, k) for w, k in _SOURCES.items() if k is not None],
+    ids=lambda v: v if isinstance(v, str) else f"{v[0]}.{v[1]}")
+def test_declared_copy_matches_its_config_source(
+        where: tuple[str, str], key: str) -> None:
+    copy = getattr(_MODULES[where[0]], where[1])
+    source = _config.REGEXES[key]
+    assert copy.pattern == source.pattern, f"{where[1]} vs REGEXES[{key!r}]"
+    assert copy.flags == source.flags, f"{where[1]} vs REGEXES[{key!r}]"
+
+
+def test_every_hand_copied_pattern_is_declared() -> None:
+    """The roster must cover every compiled pattern in these modules.
+
+    Without this, the roster is just another list that a new constant
+    can be left out of -- which is how the four above went unpinned.
+    """
+    undeclared = [
+        (name, attr)
+        for name, mod in _MODULES.items()
+        for attr, value in vars(mod).items()
+        if attr.startswith("_") and not attr.startswith("__")
+        and isinstance(value, re.Pattern)
+        and (name, attr) not in _SOURCES
+    ]
+    assert not undeclared, (
+        f"compiled patterns missing from _SOURCES: {undeclared}. Add each "
+        f"with its nameparser.config.regexes key, or None if it has no "
+        f"config counterpart.")
+
+
+def test_comma_char_matches_the_pipeline_comma_set() -> None:
+    # _render splits on the same comma characters segment does; the set
+    # lives in _state, so this one is pinned against that, not config.
+    from nameparser._pipeline._state import COMMA_CHARS
+
+    assert set(_render._COMMA_CHAR.pattern.strip("[]")) == set(COMMA_CHARS)