docs+test: round-2 review polish — session qualifier, helper reuse, regression test

- frozen_timestamp docstring and TestChangesetDateStamping class
  docstring now carry the same per-session qualifier as every other
  statement of the never-share-a-second guarantee (round 1 missed
  these two spots).
- test_nested_frozen_timestamp_reuses_outer_stamp builds its editor via
  the file's _make_manager helper instead of a raw DocxXMLEditor
  construction.
- New test_clock_regression_keeps_dates_monotonic drives the settable
  clock strictly backwards, pinning the documented NTP-step-back
  behavior (dates never regress; previous+1 until the clock catches
  up) — previously only the equality branch was exercised.

Author: pablospe

docx_editor/xml_editor.py

@@ -1313,8 +1313,9 @@ def frozen_timestamp(self) -> Iterator[None]:
         one edit as several groups.
 
         One changeset = one outermost ``frozen_timestamp()`` scope, stamped
-        via ``_get_next_changeset_timestamp`` (collision-bumped so two changesets
-        never share a second). Reentrant by reuse: a nested entry joins the
+        via ``_get_next_changeset_timestamp`` (collision-bumped so two
+        changesets by the same author never share a second within one open
+        session). Reentrant by reuse: a nested entry joins the
         enclosing changeset — ``batch_edit``/``batch_rewrite`` open the scope
         once for the whole call and the per-op ``_grouped()`` freezes join
         it. Only the outermost entry allocates a stamp and clears it on exit.

tests/test_revision_groups.py

@@ -890,10 +890,10 @@ class TestChangesetDateStamping:
     """Collision-bumped w:date stamping at changeset granularity (ISSUES.md #53).
 
     One changeset = one single edit call or one whole batch_edit/batch_rewrite
-    call. Distinct changesets by the same author never share a second (the
-    stamp is bumped past the previous one on collision), so parse-time
-    reconstruction (#46) never merges them; all ops of one batch call share
-    one date by design.
+    call. Within one open session, distinct changesets by the same author
+    never share a second (the stamp is bumped past the previous one on
+    collision), so parse-time reconstruction (#46) never merges them; all ops
+    of one batch call share one date by design.
     """
 
     def test_batch_ops_share_one_date(self, temp_docx, ticking_clock):
@@ -977,6 +977,20 @@ def test_drift_bounded_by_changesets_per_second(self, temp_docx, settable_clock)
                 datetime(2025, 6, 1, 12, 0, 10, tzinfo=timezone.utc),
             }
 
+    def test_clock_regression_keeps_dates_monotonic(self, temp_docx, settable_clock):
+        # A clock step back (e.g. NTP) is treated as a collision: dates
+        # never go backwards, pinned at previous+1 per changeset until
+        # the clock catches up.
+        with Document.open(temp_docx) as doc:
+            ref = find_ref(doc, "quick brown fox")
+            first = doc.replace("quick", "speedy", paragraph=ref)
+            settable_clock.current = datetime(2025, 6, 1, 11, 59, 30)
+            doc.replace("lazy", "sleepy", paragraph=first)
+            assert {rev.date for rev in doc.list_revisions()} == {
+                datetime(2025, 6, 1, 12, 0, 0, tzinfo=timezone.utc),
+                datetime(2025, 6, 1, 12, 0, 1, tzinfo=timezone.utc),
+            }
+
     def test_two_batches_same_second_get_distinct_dates(self, temp_docx, frozen_clock):
         # Two batch_edit calls are two changesets even inside one real
         # second — distinct dates, two inferred groups after reopen.
@@ -997,7 +1011,7 @@ def test_nested_frozen_timestamp_reuses_outer_stamp(self, temp_xml):
         # frozen_timestamp is reentrant-by-reuse: an inner scope joins the
         # enclosing changeset (batch wrapper + per-op _grouped). Only the
         # outermost entry allocates a stamp; only the outermost exit clears.
-        editor = DocxXMLEditor(temp_xml("<w:p><w:r><w:t>x</w:t></w:r></w:p>"), rsid="00000000", author=AUTHOR_B)
+        editor = _make_manager(temp_xml("<w:p><w:r><w:t>x</w:t></w:r></w:p>")).editor
         with editor.frozen_timestamp():
             outer = editor._frozen_timestamp
             assert outer is not None