Replay id registrations at the node they were registered for (#356)

The shadow's id registry recorded only the attribute name and namespace,
so the replay registered every matching attribute of the private copy.
That is not a harmless superset: an element the caller never registered,
sharing the id value and coming first, claims the value at xmlGetID and
the intended element is skipped — a "#id" signature reference then
resolves to content the caller never vouched for.

The registry now keeps the registered elements themselves, and the replay
applies each spec at the copy's counterpart of its element: that node
alone for register_id, its subtree for add_ids (the scope xmlSecAddIDs
walks). Liveness stays decidable without weak references — every element
proxy holds a reference to its document, so an entry is dead when the
document's reference count is exactly what the registry holds and nothing
else holds its elements.

Two other faithfulness gaps in the copy, from the same review:

- the whole-document and subtree parses dropped the source document's
  base URI; they now carry docinfo.URL, so relative references resolve
  where they did before the copy.
- the reflection recorded a text-slot sync only for a parent that gained
  a fresh node, so a call that *removed* a node and left nothing fresh
  behind (an EncryptedData decrypting to empty content) went unnoticed.
  Each pre-existing node is now tagged with its child count, and a parent
  whose tagged children changed is synced too.

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

Author: mxamin

developer.md

@@ -194,17 +194,22 @@ lxml's own dump of a tree it already parsed.
 hash with our libxml2 — exactly the cross-library access the shadow forbids.
 Under the shadow they record the id-attribute specs in a registry keyed by
 document identity (`RecordId`), and every `BeginDoc` replays them onto its
-copy so that `#id` references resolve during sign/verify/decrypt. The replay
-scans the whole copy for the recorded attribute names — a superset of the
-single-node registration on the raw path, mirroring what `xmlSecAddIDs` does
-from the root. lxml's classes refuse weak references, so an entry keeps a
-strong reference to its document instead: the key (the document's address)
-can then never go stale, and a document referenced by nothing but the
-registry is provably unreachable, so its entry — and the document with it —
-is dropped before the next registration. The registry therefore tracks the
-documents still in use and never evicts a live one. The two bindings are the only places,
-together with encrypt_xml/decrypt's replacement bodies, that branch on
-`IsActive()`.
+copy so that `#id` references resolve during sign/verify/decrypt. An entry
+keeps the registered elements themselves, so a spec is replayed at exactly
+the node it was registered for — that node alone for `register_id`, its
+subtree for `add_ids`, the scope `xmlSecAddIDs` walks. Registering every
+matching attribute of the copy instead would be unsafe, not merely generous:
+an unrelated element sharing the id value would claim it first and a `#id`
+reference could then resolve to content the caller never registered. lxml's
+classes refuse weak references, so the entry keeps strong references (to the
+document and to those elements) instead: the key (the document's address) can
+then never go stale, and since every element proxy holds a reference to its
+document, a document whose reference count is exactly what the registry holds
+— and whose registered elements nothing else holds — is provably unreachable,
+so its entry, and the document with it, is dropped before the next
+registration. The registry therefore tracks the documents still in use and
+never evicts a live one. The two bindings are the only places, together with
+encrypt_xml/decrypt's replacement bodies, that branch on `IsActive()`.
 
 ## Converting a binding
 

src/ds.c

@@ -220,7 +220,8 @@ static PyObject* PyXmlSec_SignatureContextRegisterId(PyObject* self, PyObject* a
             PyErr_SetString(PyXmlSec_Error, "missing attribute.");
             goto ON_FAIL;
         }
-        if (PyXmlSec_LxmlShadowRecordId(node, id_attr, id_ns) < 0) {
+        // Scope 0: this node alone, exactly what the fast path registers.
+        if (PyXmlSec_LxmlShadowRecordId(node, id_attr, id_ns, 0) < 0) {
             goto ON_FAIL;
         }
         PYXMLSEC_DEBUGF("%p: register id - ok", self);