Refactor initialize.hpp: de-template compiler to fix 32-bit MSVC C1060

Move the policy-independent dispatch-table-construction algorithm (~1300 lines)
from the doubly-nested template registry<Policies...>::compiler<Options...> into
the non-template detail::generic_compiler, so it compiles once per TU instead of
once per distinct registry type. This fixes the 32-bit MSVC (cl.exe, ~2GB VA space)
C1060 "compiler out of heap space" error when test_compiler.cpp etc. defined
multiple registries.

Key changes:
- Add abstract trace_sink with per-registry trace_sink_impl<Registry> virtual
  overrides (5 small virtuals per registry instead of hundreds of operator<<
  instantiations).
- Move all algorithm member functions to detail::generic_compiler (now non-
  template): build_class_lattice, assign_slots, build_dispatch_tables, etc.
  Replace if constexpr(has_trace) with if(tr.on()) and has_option<n2216> with
  use_n2216.
- Reduce registry<...>::compiler<> to a thin shim: resolve_classes,
  resolve_methods, ctor binding tr.sink to the concrete sink impl, and
  install_global_tables running policies then swapping dispatch_data into
  registry::state.
- All changes confined to initialize.hpp. Remove test/Jamfile's
  <toolset>msvc-14.5,<address-model>32:<build>no skip now that 32-bit works.
- Add trace_demo.cpp example: demonstrates dispatch/next/tracing with
  BOOST_OPENMETHOD_TRACE=1.

Verified: MSVC 14.5 x86_64 full suite pass; MSVC 14.5 x86_32 full suite pass
(C1060 gone); gcc 13.4 -Werror clean; trace output identical (byte-for-byte
after address normalization).

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: jll63

doc/modules/ROOT/examples/trace_demo.cpp

@@ -0,0 +1,78 @@
+// Copyright (c) 2018-2025 Jean-Louis Leroy
+// Distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE_1_0.txt
+// or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// Demonstrates tracing the construction of the dispatch tables. The example
+// exercises single dispatch, `next`, and multiple dispatch. Run it with the
+// environment variable BOOST_OPENMETHOD_TRACE=1 to print a detailed trace of
+// the inheritance lattice, slot allocation, dispatch tables and `next` links
+// to stderr.
+
+#include <iostream>
+#include <memory>
+
+#include <boost/openmethod.hpp>
+#include <boost/openmethod/initialize.hpp>
+
+using boost::openmethod::virtual_ptr;
+
+struct Animal {
+    virtual ~Animal() = default;
+};
+struct Dog : Animal {};
+struct Cat : Animal {};
+struct Bulldog : Dog {};
+
+BOOST_OPENMETHOD_CLASSES(Animal, Dog, Cat, Bulldog);
+
+// Single dispatch, with an overrider that calls `next`.
+BOOST_OPENMETHOD(poke, (std::ostream&, virtual_ptr<Animal>), void);
+
+BOOST_OPENMETHOD_OVERRIDE(poke, (std::ostream & os, virtual_ptr<Dog>), void) {
+    os << "growls";
+}
+
+BOOST_OPENMETHOD_OVERRIDE(
+    poke, (std::ostream & os, virtual_ptr<Bulldog> dog), void) {
+    next(os, dog); // -> the Dog overrider
+    os << " and bites";
+}
+
+// Multiple dispatch.
+BOOST_OPENMETHOD(
+    meet, (std::ostream&, virtual_ptr<Animal>, virtual_ptr<Animal>), void);
+
+BOOST_OPENMETHOD_OVERRIDE(
+    meet, (std::ostream & os, virtual_ptr<Animal>, virtual_ptr<Animal>), void) {
+    os << "ignore each other";
+}
+
+BOOST_OPENMETHOD_OVERRIDE(
+    meet, (std::ostream & os, virtual_ptr<Dog>, virtual_ptr<Cat>), void) {
+    os << "the dog chases the cat";
+}
+
+BOOST_OPENMETHOD_OVERRIDE(
+    meet, (std::ostream & os, virtual_ptr<Cat>, virtual_ptr<Dog>), void) {
+    os << "the cat flees the dog";
+}
+
+auto main() -> int {
+    namespace bom = boost::openmethod;
+
+    // `trace::from_env()` enables tracing when BOOST_OPENMETHOD_TRACE=1 is set.
+    // Pass `bom::trace(true)` instead to force tracing on unconditionally.
+    bom::initialize(bom::trace::from_env());
+
+    std::unique_ptr<Animal> hector = std::make_unique<Bulldog>();
+    std::unique_ptr<Animal> felix = std::make_unique<Cat>();
+
+    poke(std::cout, *hector); // growls and bites
+    std::cout << ".\n";
+
+    meet(std::cout, *hector, *felix); // the dog chases the cat
+    std::cout << ".\n";
+
+    return 0;
+}