trace: summarize used slots per inheritance lattice

The trace showed slot assignment only as it happened, interleaved with the
recursive walk, so the picture was scattered and the fact that numbering
restarts in each disjoint hierarchy was invisible.

Add a block at the end of the trace listing, for each lattice, the used slots
with the method and virtual parameter assigned to each, then every class's
occupied v-table range. A lattice is a connected component of the class graph,
identified by its root classes - multiple inheritance is what gives it more
than one.

The listing is driven off used_by_vp and method::slots rather than used_slots,
which assign_tree_slots never fills in. Sibling branches of a tree lattice
restart from the same next_slot, so a slot number can repeat within a lattice;
the owning class is printed to disambiguate.

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

Author: jll63

include/boost/openmethod/initialize.hpp

@@ -564,6 +564,7 @@ struct registry<Policies...>::compiler : detail::generic_compiler {
         bool concrete);
     void write_global_data();
     void print(const method_report& report) const;
+    void print_slots();
     static void select_dominant_overriders(
         std::vector<overrider*>& dominants, std::size_t& pick,
         std::size_t& remaining);
@@ -594,6 +595,7 @@ void registry<Policies...>::compiler<Options...>::install_global_tables() {
     write_global_data();
 
     print(report);
+    print_slots();
     ++tr << "Finished\n";
 }
 
@@ -1834,6 +1836,117 @@ void registry<Policies...>::compiler<Options...>::print(
        << " ambiguous\n";
 }
 
+template<class... Policies>
+template<class... Options>
+void registry<Policies...>::compiler<Options...>::print_slots() {
+    if constexpr (has_trace) {
+        if (!tr.on) {
+            return;
+        }
+
+        using namespace detail;
+
+        // Slot numbering is scoped to a connected component of the class
+        // graph, so partition the classes into components first. A component
+        // is identified by the classes in it that have no direct bases; there
+        // is more than one only in presence of multiple inheritance.
+        std::unordered_map<const class_*, std::size_t> component;
+        std::size_t component_count = 0;
+
+        for (auto& seed : classes) {
+            if (component.find(&seed) != component.end()) {
+                continue;
+            }
+
+            auto id = component_count++;
+            component[&seed] = id;
+            std::vector<class_*> todo{&seed};
+
+            while (!todo.empty()) {
+                auto cls = todo.back();
+                todo.pop_back();
+
+                for (auto neighbors :
+                     {&cls->direct_bases, &cls->direct_derived}) {
+                    for (auto next : *neighbors) {
+                        if (component.emplace(next, id).second) {
+                            todo.push_back(next);
+                        }
+                    }
+                }
+            }
+        }
+
+        // Collect the members in 'classes' order, for a deterministic trace.
+        std::vector<std::vector<class_*>> lattices(component_count);
+
+        for (auto& cls : classes) {
+            lattices[component[&cls]].push_back(&cls);
+        }
+
+        ++tr << "Used slots:\n";
+        indent _(tr);
+
+        for (auto& lattice : lattices) {
+            std::vector<class_*> roots;
+
+            for (auto cls : lattice) {
+                if (cls->direct_bases.empty()) {
+                    roots.push_back(cls);
+                }
+            }
+
+            ++tr << roots << "\n";
+            indent _2(tr);
+
+            struct entry {
+                std::size_t slot;
+                class_* cls;
+                parameter mp;
+            };
+
+            std::vector<entry> slots;
+
+            for (auto cls : lattice) {
+                for (const auto& mp : cls->used_by_vp) {
+                    slots.push_back({mp.method->slots[mp.param], cls, mp});
+                }
+            }
+
+            std::stable_sort(
+                slots.begin(), slots.end(),
+                [](const entry& a, const entry& b) { return a.slot < b.slot; });
+
+            ++tr << "slots:\n";
+
+            {
+                indent _3(tr);
+
+                for (const auto& e : slots) {
+                    ++tr << e.slot << ": in " << *e.cls << " for "
+                         << type_name(e.mp.method->infos[0]->method_type_id)
+                         << " parameter " << e.mp.param << "\n";
+                }
+            }
+
+            ++tr << "v-tables:\n";
+
+            {
+                indent _3(tr);
+
+                for (auto cls : lattice) {
+                    if (cls->vtbl.empty()) {
+                        continue;
+                    }
+
+                    ++tr << *cls << " slots " << cls->first_slot << "-"
+                         << (cls->first_slot + cls->vtbl.size() - 1) << "\n";
+                }
+            }
+        }
+    }
+}
+
 //! Initialize a registry.
 //!
 //! Initialize the @ref registry passed as an explicit function template