refactor(document): share the element registry and adapter eleven engines pasted

[andiwand]

🤖 Generated with Claude Code

Closes #770 (parts 1–2 of the four it lists; the style registries and the
DecodedFile accessors are still open).

Every engine that builds an element tree shipped its own copy of the same flat
store, the same five tree links, the same element_at / append_child, and the
same ~30 lines of adapter navigation followed by one four-line
*_adapter(id) hook per element type. This puts that machinery in
internal/common/ and ports all eleven engines onto it.

37 files changed, 979 insertions(+), 2916 deletions(-)

380 of those insertions are the two new headers. Registry code across the ten
registries: 3028 → 1726 lines. No engine writes a *_adapter(id) hook or a
navigation method any more.

What is shared

internal/common/element_registry.hpp

• ElementNode<Id> — the five links plus the type, stored Id wide.
• SideTable<T> (hashed) and SortedSideTable<T, Id> (odf's sorted deque,
  promoted) — a per-type payload keyed by element id. Both carry their own
  bounds check, so an engine's accessor is return m_texts.at(id); and the
  per-payload check_*_id is gone.
• ElementRegistry<Element, Id> — the store (id = index + 1), element_at,
  append_child, link_child, check_element_id, and the id-overflow guard.

The store is a std::deque for every engine now. That is what odf already did,
for the reason it applies everywhere: create_element_ hands the parser back an
Element &, and a vector both invalidates it and peaks holding two copies. The
ooxml engines were on a vector; nothing there held a reference across a create,
so this is a hazard removed rather than a bug fixed.

internal/common/element_adapter.hpp

ElementAdapter<Adapters…> inherits the per-type adapters named in its pack and
answers all 24 *_adapter(id) hooks from them:

template <typename Adapter, ElementType type>
const Adapter *adapter_(const ElementIdentifier element_id) const {
  if constexpr ((std::is_same_v<Adapter, Adapters> || ...)) {
    return element_type(element_id) == type ? this : nullptr;
  } else {
    return nullptr;
  }
}

Taking the adapters as template arguments rather than using CRTP keeps the
condition off the derived class, which would not be complete when a compiler
that instantiates virtual member bodies eagerly gets there. It also checks out
against the tree: the hook ↔ ElementType mapping was already 1:1 and identical
in all eleven engines.

It also carries the defaults every engine had verbatim — element_is_unique and
element_is_self_locatable true, element_is_editable false, and the two
util::document path forwards. Only odf and ooxml text override
element_is_editable, which is the only place the answer was ever different.

RegistryElementAdapter<Registry, Adapters…> adds the six navigation methods
over m_registry->element_at(id).

What each engine keeps

Its payload structs, its create_*_element, its secondary-chain append_*, and
its real per-type methods. rtf is now the whole pattern in 34 header lines:

class ElementRegistry final
    : public internal::ElementRegistry<ElementNode<ElementIdentifier>> {
public:
  struct Text final {
    std::string text;
  };

  std::tuple<ElementIdentifier, Element &> create_element(ElementType type);
  std::tuple<ElementIdentifier, Element &, Text &> create_text_element();

  [[nodiscard]] Text &text_element_at(const ElementIdentifier id) {
    return m_texts.at(id);
  }
  [[nodiscard]] const Text &text_element_at(const ElementIdentifier id) const {
    return m_texts.at(id);
  }

private:
  SideTable<Text> m_texts;
};

csv packs a kind and a coordinate into its id rather than keeping a registry,
so it takes ElementAdapter alone and keeps its own navigation.

Drift swept up on the way

• clear() was dead in all ten registries — nothing has ever called it.
• The three ooxml append_child had lost the "child already has a parent" guard
  every other engine kept; link_child restores it.
• Thrown messages said DocumentElementRegistry::, a name no class has carried
  for a while.

Docs

AGENTS.md taught the copy — it named ppt_element_registry.* as the thing to
model, and rtf/AGENTS.md said its registry was "copied from oldms/text". The
element-adapter pattern section now leads with the machinery is shared — do
not write it again, says what an engine actually writes, and points at rtf.
odf/AGENTS.md and ooxml/AGENTS.md follow.

Verification

• Full suite: 1442 passed, 6 skipped, 0 failed. The reference HTML is
  byte-identical, which is the real claim here — this changes no behaviour.
• -Werror build clean, clang-tidy clean on all 27 touched translation units.
• The element struct is the same size as before (odf 32 bytes, ooxml 56) —
  ElementNode as a base costs nothing — and peak RSS on a 4.5 MB .ods is
  unchanged.

No CHANGELOG.md entry: refactoring is in the generated per-PR list already.

Merge order

#821 collapses the four drawing element types into frame, which touches four
entries in the shared hook list and in odf's adapter pack. It is the breaking
one, so this should go first and #821 rebase onto it — the conflict is a handful
of lines either way.