fix: unbreak the GCC build, and address review of the registry recipe

The doc comment added for BOOST_OPENMETHOD_DEFAULT_REGISTRY ended a `//!` line
with a backslash, making it a line continuation. GCC's -Wcomment (in -Wall)
rejects that under -Werror, so every GCC job on both CIs failed while every
clang, MSVC and Xcode job passed. Put the #define on one line. Verified by
reproducing the exact diagnostic with the pre-fix header and confirming g++
-Wall -Wextra -Werror accepts the fixed one.

Restore the coverage lost with deferred_custom_rtti.cpp. That example was the
only place combining deferred_static_rtti with virtual bases and
dynamic_cast_ref: test_custom_rtti_virtual_base.cpp has the virtual bases and
the cast but derives from policies::rtti, and test_custom_rtti_deferred.cpp had
neither. Add Bat and Owl, virtually derived, plus the dynamic_cast_ref the cast
now needs - `requires_dynamic_cast` is true exactly when static_cast is
ill-formed, so these overriders reach the policy hook. Confirmed by sabotaging
dynamic_cast_ref and watching the test fail.

Name core.hpp, not <boost/openmethod.hpp>, as the point where the macro is read.
initialize.hpp, inplace_vptr.hpp and every interop/*.hpp also include core.hpp,
so a TU that includes one of those before the #define binds silently to
default_registry. Four places still said otherwise.

test_capture_errors.hpp now owns the whole recipe - declaration, #define,
include and test_registry - instead of the seven tests repeating it. There is no
ordering left for a caller to get wrong, which is what the previous version's
comment had claimed without being able to guarantee it. Those tests no longer
name the macro, so test/CMakeLists.txt would have handed them the shared PCH and
silently defeated the override; teach its scan to follow the header too.

Documentation fixes from the same review:

- ref_headers.adoc claimed every stock policy has its own header; indirect_vptr,
  runtime_checks and deferred_static_rtti live in preamble.hpp. Say so, and note
  runtime_checks joins default_registry under
  BOOST_OPENMETHOD_ENABLE_RUNTIME_CHECKS.
- custom_rtti.adoc pointed at a declaration "at the top of the file" that sits
  below the classes listing, and its Deferred RTTI section never showed the
  declaration step at all - example 2's setup and registry tags were unrendered.
- error_handling.adoc's listing opened with five lines of registry boilerplate
  its prose never introduced.
- shared_libraries.adoc's my_registry.hpp is a complete header now, so give it
  the include guard the animals.hpp it is compared to has.
- CLAUDE.md cited a line number that had already moved, pointed at greps in a
  section that has none, miscounted the files carrying the macro, and described
  an unqualified `registry` as resolving silently when it is a hard error.

Remove doc/modules/ROOT/examples/static_rtti.cpp: an orphan no page references,
left marker-free by the previous commit, duplicating snippets/static_rtti.cpp -
which exercises the same policy, classes and dispatch, is the copy the docs
render, and asserts more.

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

Author: jll63

CLAUDE.md

@@ -335,10 +335,15 @@ is a single symbol) and `test/implicit_shared_libraries/`.
 
 ### Overriding the default registry
 
-The registry is **forward-declared** before `<boost/openmethod.hpp>` and **defined after** it.
-Do not reintroduce the old "include a pre-core header, define the registry, `#define`, then
-include" idiom - `preamble.hpp` and `default_registry.hpp` appear nowhere outside `include/`,
-and the greps in *Development Workflow* enforce that.
+The registry is **forward-declared** before `core.hpp` - or any header that includes it,
+`<boost/openmethod.hpp>` among them - and **defined after**. Do not reintroduce the old
+"include a pre-core header, define the registry, `#define`, then include" idiom:
+`preamble.hpp` and `default_registry.hpp` should appear nowhere outside `include/`. Nothing
+enforces that automatically; check it by hand when touching this area:
+
+```bash
+git grep -n "openmethod/preamble.hpp\|openmethod/default_registry.hpp" -- doc test
+```
 
 ```cpp
 struct my_registry;
@@ -370,18 +375,22 @@ rules:
 - The registry must be **complete** before the first construct that instantiates it: a
   `BOOST_OPENMETHOD*` macro, `use_classes`, `method`, `virtual_ptr`, `inplace_vptr_base`,
   `initialize()`, or `BOOST_OPENMETHOD_{IMPORT,EXPORT,INSTANTIATE}_REGISTRY`. Violating this is
-  a hard error (`incomplete type ... used in nested name specifier`, `core.hpp:376`) - never
-  silent.
+  a hard error (`incomplete type ... used in nested name specifier`, from `use_class_aux` in
+  `core.hpp`) - never silent.
 - It must name a **class**, declared with the same class-key (`struct`) as the definition. A
   `class`/`struct` mismatch is MSVC C4099, an error under the suite's `/W4 /WX`.
-- **Qualify** the name if it could also be found in `namespace boost::openmethod`.
-  `#define BOOST_OPENMETHOD_DEFAULT_REGISTRY registry` silently resolves to
-  `boost::openmethod::registry` and fails with `missing template arguments`; `::registry` works.
-
-`test/CMakeLists.txt` scans each `test_*.cpp` for the token `BOOST_OPENMETHOD_DEFAULT_REGISTRY`
-and withholds the shared PCH from any file that has it - a force-included PCH would still
-precede the `#define`. That detection is unaffected by the ordering, but the count matters:
-17 files under `test/` carry the macro.
+- **Qualify** the name if it could also be found in `namespace boost::openmethod`. The macro
+  is expanded inside that namespace, so `#define BOOST_OPENMETHOD_DEFAULT_REGISTRY registry`
+  binds to `boost::openmethod::registry` rather than the global one. That one is loud -
+  `missing template arguments` - but a name that *does* resolve would bind to the wrong type
+  silently. `::registry` works.
+
+`test/CMakeLists.txt` withholds the shared PCH from any `test_*.cpp` that overrides the
+registry - a force-included PCH would still precede the `#define`. It detects them by scanning
+for the token `BOOST_OPENMETHOD_DEFAULT_REGISTRY` **or** for an include of a header that
+carries the override on the file's behalf (`test_capture_errors.hpp`). Add another such header
+and the scan has to learn about it: miss one and the file still compiles, binds to
+`default_registry`, and fails at run time.
 
 ### Custom RTTI
 When `<typeinfo>` is unavailable or insufficient, use static_rtti or implement custom RTTI. See `doc/modules/ROOT/examples/custom_rtti/` and policies in `include/boost/openmethod/policies/`.

doc/modules/ROOT/examples/static_rtti.cpp

@@ -92,7 +92,8 @@ two lines before the library is included: a declaration of the registry class,
 and a definition of
 xref:reference:BOOST_OPENMETHOD_DEFAULT_REGISTRY.adoc[BOOST_OPENMETHOD_DEFAULT_REGISTRY]
 naming it. The registry itself comes further down; only its _name_ has to be
-known when `<boost/openmethod.hpp>` is parsed.
+known when `<boost/openmethod/core.hpp>` is parsed - which any header that
+includes it, `<boost/openmethod.hpp>` among them, does for you.
 
 [source,c++]
 ----
@@ -135,8 +136,8 @@ small, dense range. It means that we can use them as indexes in a vector.
 include::{example}/1/custom_rtti.cpp[tag=registry]
 ----
 
-This is the definition promised by the declaration at the top of the file. It
-must appear before the first `BOOST_OPENMETHOD`, `BOOST_OPENMETHOD_OVERRIDE` or
+This is the definition promised by the declaration shown above. It must appear
+before the first `BOOST_OPENMETHOD`, `BOOST_OPENMETHOD_OVERRIDE` or
 `BOOST_OPENMETHOD_CLASSES`: those instantiate the registry, and an incomplete
 type will not do.
 
@@ -173,3 +174,16 @@ postpones reading the type ids until `initialize` is called:
 ----
 include::{example}/2/custom_rtti.cpp[tag=policy]
 ----
+
+The setup is the same as before - the registry is declared, named as the default,
+and defined once the library is in scope:
+
+[source,c++]
+----
+include::{example}/2/custom_rtti.cpp[tag=setup]
+----
+
+[source,c++]
+----
+include::{example}/2/custom_rtti.cpp[tag=registry]
+----

doc/modules/ROOT/pages/custom_rtti.adoc

@@ -24,8 +24,12 @@ not implemented
 spin
 ----
 
-We can also replace the `error_handler` policy with our own.
-For example:
+We can also replace the `error_handler` policy with our own. Since the handler
+is part of the registry, this means overriding the default registry: the
+listing opens by declaring `custom_registry` and naming it in
+xref:reference:BOOST_OPENMETHOD_DEFAULT_REGISTRY.adoc[BOOST_OPENMETHOD_DEFAULT_REGISTRY],
+then defines it further down, once the policy it is built from exists. See
+xref:registries_and_policies.adoc[Registries and Policies] for that recipe.
 
 
 [source,c++]

doc/modules/ROOT/pages/error_handling.adoc

@@ -106,7 +106,7 @@ parameters.
 
 ## Policy Headers
 
-Each stock policy lives in a header of its own. The five that make up
+Most stock policies live in a header of their own. Those that make up
 cpp:default_registry[] come in with `<boost/openmethod.hpp>`; the others are
 included explicitly. A policy header depends on nothing but the library's
 foundations, so it may be included in any order relative to
@@ -115,6 +115,11 @@ that overrides
 xref:reference:BOOST_OPENMETHOD_DEFAULT_REGISTRY.adoc[`BOOST_OPENMETHOD_DEFAULT_REGISTRY`]
 puts it.
 
+Three policies have no header of their own: cpp:indirect_vptr[],
+cpp:runtime_checks[] and cpp:deferred_static_rtti[] are defined alongside
+`registry` itself, and are available as soon as `<boost/openmethod.hpp>` has
+been included.
+
 ### link:{headers-url}/boost/openmethod/policies/std_rtti.hpp[<boost/openmethod/policies/std_rtti.hpp>]
 
 Provides an implementation of the `rtti` policy using standard RTTI. Part of
@@ -142,6 +147,10 @@ the library aborts the program. Part of `default_registry`.
 Provides an implementation of the `output` policy that writes diagnostics to
 the C standard error stream (not using iostreams). Part of `default_registry`.
 
+NOTE: `default_registry` also contains `runtime_checks` when
+xref:reference:BOOST_OPENMETHOD_ENABLE_RUNTIME_CHECKS.adoc[`BOOST_OPENMETHOD_ENABLE_RUNTIME_CHECKS`]
+is defined. That policy needs no header - see above.
+
 ### link:{headers-url}/boost/openmethod/policies/static_rtti.hpp[<boost/openmethod/policies/static_rtti.hpp>]
 
 Provides a minimal implementation of the `rtti` policy that does not depend on

doc/modules/ROOT/pages/ref_headers.adoc

@@ -7,14 +7,16 @@ different registries, it must be registered with each of them.
 
 Class templates cpp:use_classes[], cpp:method[], cpp:virtual_ptr[], and macros
 xref:reference:BOOST_OPENMETHOD.adoc[BOOST_OPENMETHOD] and
-xref:reference:BOOST_OPENMETHOD_CLASSES.adoc[BOOST_OPENMETHOD_CLASSES], take an additional
-argument, a cpp:registry[] class, which defaults to cpp:default_registry[]. The
-default registry can be overridden by defining the macroprocessor symbol
+xref:reference:BOOST_OPENMETHOD_CLASSES.adoc[BOOST_OPENMETHOD_CLASSES], take an
+additional argument, a cpp:registry[] class, which defaults to
+cpp:default_registry[]. The default registry can be overridden by defining the
+preprocessor symbol
 xref:reference:BOOST_OPENMETHOD_DEFAULT_REGISTRY.adoc[BOOST_OPENMETHOD_DEFAULT_REGISTRY]
-_before_ including `<boost/openmethod.hpp>`. The value of the symbol is used as
-a default template parameter for `use_classes`, `method`, `virtual_ptr`, and
-others. Once the header has been included, changing
-`BOOST_OPENMETHOD_DEFAULT_REGISTRY` has no effect.
+_before_ including `<boost/openmethod/core.hpp>` (or any header that includes
+it, like `<boost/openmethod.hpp>`). The value of the symbol is used as a default
+template parameter for `use_classes`, `method`, `virtual_ptr`, and others. Once
+it has been included, changing `BOOST_OPENMETHOD_DEFAULT_REGISTRY` has no
+effect.
 
 For a registry the library provides, that is the whole recipe:
 
@@ -84,7 +86,7 @@ Policies are placed in the cpp:boost::openmethod::policies[] namespace.
 
 |===
 
-if
+If
 xref:reference:BOOST_OPENMETHOD_ENABLE_RUNTIME_CHECKS.adoc[BOOST_OPENMETHOD_ENABLE_RUNTIME_CHECKS]
 is defined, `default_registry` also contains the `runtime_checks` policy. This
 enables extra validations during method dispatch, which can detect missing class
@@ -148,7 +150,7 @@ left to right; cpp:finalize[] calls each policy's `finalize` in the reverse
 order. A policy that depends on another policy having been initialized must
 therefore be listed _after_ its dependency. In particular, `vptr_vector` reads
 the state of the `type_hash` policy, so the `type_hash` policy must come before
-`vptr_vector` — as in `default_registry` above, where `fast_perfect_hash`
+`vptr_vector` - as in `default_registry` above, where `fast_perfect_hash`
 precedes `vptr_vector`. This particular requirement is enforced with a
 `static_assert`.
 
@@ -162,7 +164,7 @@ struct indirect_registry : default_registry::with<policies::indirect_vptr> {};
 ----
 
 Policies are implemented as unary
-https://www.boost.org/doc/libs/1_89_0/libs/mp11/doc/html/mp11.html[Boost.MP11
+https://www.boost.org/doc/libs/latest/libs/mp11/doc/html/mp11.html[Boost.MP11
 quoted metafunctions]. A policy is an ordinary class that contains a nested
 class template `fn`, which is instantiated by the registry, passing itself as
 the single template argument. The reason for this mechanism is to allow policies

doc/modules/ROOT/pages/registries_and_policies.adoc

@@ -243,7 +243,8 @@ cpp:indirect_registry[] that has the same policies as `default_registry`, plus
 `indirect_vptr`. Make it the registry the `BOOST_OPENMETHOD` macros use by
 defining
 xref:reference:BOOST_OPENMETHOD_DEFAULT_REGISTRY.adoc[BOOST_OPENMETHOD_DEFAULT_REGISTRY]
-_before_ including `<boost/openmethod.hpp>`.
+_before_ including `<boost/openmethod/core.hpp>`, or any header that includes
+it, like `<boost/openmethod.hpp>`.
 
 The `indirect_vptr` example does that in the header both modules share, rather
 than passing a compiler switch from the build system. One place then settles
@@ -279,6 +280,9 @@ A custom registry is shared exactly the same way - name it instead of
 [source,c++]
 ----
 // my_registry.hpp
+#ifndef MY_REGISTRY_DEFINED
+#define MY_REGISTRY_DEFINED
+
 struct my_registry;
 #define BOOST_OPENMETHOD_DEFAULT_REGISTRY my_registry
 
@@ -290,6 +294,8 @@ struct my_registry : boost::openmethod::registry</* policies... */> {};
 BOOST_OPENMETHOD_EXPORT_REGISTRY(my_registry);
 #else
 BOOST_OPENMETHOD_IMPORT_REGISTRY(my_registry);
+#endif
+
 #endif
 ----
 

doc/modules/ROOT/pages/shared_libraries.adoc

@@ -35,14 +35,14 @@
 //!
 //! `BOOST_OPENMETHOD_DEFAULT_REGISTRY` can be defined by a program to change
 //! the default registry globally, *before* including
-//! `<boost/openmethod.hpp>`. After that, changing its value has no effect,
+//! `<boost/openmethod/core.hpp>` (or any header that includes it, like
+//! `<boost/openmethod.hpp>`). After that, changing its value has no effect,
 //! even on other macros.
 //!
 //! To use a registry that the library provides, name it in the macro:
 //!
 //! @code
-//! #define BOOST_OPENMETHOD_DEFAULT_REGISTRY \
-//!     boost::openmethod::indirect_registry
+//! #define BOOST_OPENMETHOD_DEFAULT_REGISTRY boost::openmethod::indirect_registry
 //! #include <boost/openmethod.hpp>
 //! @endcode
 //!
@@ -1972,7 +1972,8 @@ struct validate_method_parameter<
 //! The default value for `Registry` is @ref default_registry, but it can be
 //! overridden by defining the preprocessor symbol
 //! @ref BOOST_OPENMETHOD_DEFAULT_REGISTRY, *before* including
-//! `<boost/openmethod.hpp>`. Setting the symbol afterwards has no effect.
+//! `<boost/openmethod/core.hpp>` (or any header that includes it, like
+//! `<boost/openmethod.hpp>`). Setting the symbol afterwards has no effect.
 //!
 //! Specializations of `method` have a single instance: the static member `fn`,
 //! which has an `operator()` that forwards to the appropriate overrider. It is

include/boost/openmethod/core.hpp

@@ -89,7 +89,8 @@ struct indirect_registry : default_registry::with<policies::indirect_vptr> {};
 //! Enable runtime checks in @ref boost::openmethod::default_registry.
 //!
 //! May be defined by a program before including
-//! `<boost/openmethod.hpp>` to enable runtime checks. See
+//! `<boost/openmethod/default_registry.hpp>` (or any header that includes it,
+//! like `<boost/openmethod.hpp>`) to enable runtime checks. See
 //! @ref boost::openmethod::default_registry for details.
 //!
 //! @par Example

include/boost/openmethod/default_registry.hpp

@@ -177,8 +177,9 @@ inline constexpr bool method_not_found = false;
 //!
 //! @note The default registry is the value of
 //! @ref BOOST_OPENMETHOD_DEFAULT_REGISTRY at the point
-//! `<boost/openmethod.hpp>` is included. Changing the value of this symbol
-//! has no effect after that point.
+//! `<boost/openmethod/core.hpp>` is included, directly or through a header
+//! like `<boost/openmethod.hpp>`. Changing the value of this symbol has no
+//! effect after that point.
 //!
 //! @par Example
 //!
@@ -536,8 +537,9 @@ inline constexpr bool method_not_found = false;
 //! documentation for more details.
 //!
 //! @note The default registry is the value of
-//! @ref BOOST_OPENMETHOD_DEFAULT_REGISTRY when `<boost/openmethod.hpp>` is
-//! included. Subsequently changing it has no retroactive effect.
+//! @ref BOOST_OPENMETHOD_DEFAULT_REGISTRY when `<boost/openmethod/core.hpp>`
+//! is included, directly or through a header like `<boost/openmethod.hpp>`.
+//! Subsequently changing it has no retroactive effect.
 //!
 //! @par Examples
 //!