Implement container selector infrastructure (Phase 3.2.1)

Add complete container selector system for adjacency_list with support for
all standard container types:

New files:
- container_selectors.hpp: All selector tags and container_gen mechanism
- test_container_selectors.cpp: Comprehensive tests for all selectors

Selectors implemented:
- vecS (std::vector) - index-based descriptors
- listS (std::list) - stable iterator-based descriptors
- setS (std::set) - ordered, unique, stable descriptors
- mapS (std::set) - ordered, unique
- multisetS (std::multiset) - ordered, allows parallel edges
- hash_setS (std::unordered_set) - unordered, unique
- hash_mapS (std::unordered_set) - unordered, unique
- hash_multisetS (std::unordered_multiset) - parallel edges
- hash_multimapS (std::unordered_multiset) - parallel edges

adjacency_list changes:
- New template signature: <OutEdgeListS, VertexListS, DirectedS, VP, EP, GP>
- Implementations for vecS, listS, setS vertex containers
- Added simple_adjacency_list alias for backward compatibility
- Added std::hash specialization for stored_out_edge

All 27 tests pass.

Author: pratzl

modern/examples/bfs_lambda_visitor.cpp

@@ -6,6 +6,7 @@
 
 #include <bgl/modern/adjacency_list.hpp>
 #include <bgl/modern/breadth_first_search.hpp>
+#include <bgl/modern/visitor_callbacks.hpp>
 #include <iostream>
 #include <vector>
 #include <string>
@@ -21,7 +22,7 @@ int main() {
     std::cout << "=== BFS with Lambda Visitors ===\n\n";
 
     // Create a graph representing a directory structure
-    adjacency_list<directed_tag, VertexProps> g(10);
+    simple_adjacency_list<directed_tag, VertexProps> g(10);
 
     g[0] = {"root", 0};
     g[1] = {"home", 1};
@@ -61,13 +62,11 @@ int main() {
     // Example 2: Tree edge tracking
     std::cout << "\n2. Tree structure:\n";
     {
-        bfs_callbacks callbacks{
-            .on_tree_edge = [&g](auto e, const auto& graph) {
-                auto src = source(e, graph);
-                auto tgt = target(e, graph);
-                std::cout << "  " << g[src].name << " -> " << g[tgt].name << "\n";
-            }
-        };
+        auto callbacks = on_tree_edge([&g](auto e, const auto& graph) {
+            auto src = source(e, graph);
+            auto tgt = target(e, graph);
+            std::cout << "  " << g[src].name << " -> " << g[tgt].name << "\n";
+        });
 
         breadth_first_search(g, 0, callbacks);
     }
@@ -77,11 +76,9 @@ int main() {
     {
         std::vector<std::vector<std::string>> levels(4);
 
-        bfs_callbacks callbacks{
-            .on_discover_vertex = [&](auto v, const auto&) {
-                levels[g[v].value].push_back(g[v].name);
-            }
-        };
+        auto callbacks = on_discover_vertex([&](auto v, const auto&) {
+            levels[g[v].value].push_back(g[v].name);
+        });
 
         breadth_first_search(g, 0, callbacks);
 
@@ -100,23 +97,18 @@ int main() {
         int edge_count = 0;
         int vertex_count = 0;
 
-        bfs_callbacks callbacks{
-            .on_initialize_vertex = [&](auto v, const auto& graph) {
-                vertex_count++;
-            },
-            .on_discover_vertex = [&g](auto v, const auto&) {
-                std::cout << "  → Discovered " << g[v].name << "\n";
-            },
-            .on_examine_vertex = [&g](auto v, const auto&) {
-                std::cout << "  ⊙ Examining " << g[v].name << "\n";
-            },
-            .on_tree_edge = [&](auto e, const auto& graph) {
-                edge_count++;
-            },
-            .on_finish_vertex = [&g](auto v, const auto&) {
-                std::cout << "  ✓ Finished " << g[v].name << "\n";
-            }
-        };
+        // For multiple callbacks, chain the helper functions
+        auto callbacks = bfs_callbacks(
+            [&](auto v, const auto& graph) { vertex_count++; },  // initialize
+            [&g](auto v, const auto&) { std::cout << "  → Discovered " << g[v].name << "\n"; },  // discover
+            [&g](auto v, const auto&) { std::cout << "  ⊙ Examining " << g[v].name << "\n"; },  // examine
+            null_callback{},  // examine_edge
+            [&](auto e, const auto& graph) { edge_count++; },  // tree_edge
+            null_callback{},  // non_tree_edge
+            null_callback{},  // gray_target
+            null_callback{},  // black_target
+            [&g](auto v, const auto&) { std::cout << "  ✓ Finished " << g[v].name << "\n"; }  // finish
+        );
 
         breadth_first_search(g, 0, callbacks);
 
@@ -158,20 +150,34 @@ int main() {
             double avg_out_degree = 0.0;
         } stats;
 
-        bfs_callbacks callbacks{
-            .on_examine_vertex = [&](auto v, const auto& graph) {
-                stats.total_vertices++;
-                auto degree = out_degree(v, graph);
-                stats.avg_out_degree += degree;
-                
-                if (degree == 0) {
-                    stats.leaf_nodes++;
-                } else {
-                    stats.internal_nodes++;
-                }
+        // Multiple events require the full bfs_callbacks struct
+        // We pass all callbacks in constructor order
+        auto examine_cb = [&](auto v, const auto& graph) {
+            stats.total_vertices++;
+            auto degree = out_degree(v, graph);
+            stats.avg_out_degree += degree;
+            
+            if (degree == 0) {
+                stats.leaf_nodes++;
+            } else {
+                stats.internal_nodes++;
             }
         };
 
+        auto callbacks = bfs_callbacks<
+            null_callback,  // initialize
+            null_callback,  // discover
+            decltype(examine_cb),  // examine
+            null_callback,  // examine_edge
+            null_callback,  // tree_edge
+            null_callback,  // non_tree_edge
+            null_callback,  // gray_target
+            null_callback,  // black_target
+            null_callback   // finish
+        >{
+            .on_examine_vertex = examine_cb
+        };
+        
         breadth_first_search(g, 0, callbacks);
 
         stats.avg_out_degree /= stats.total_vertices;

modern/examples/dijkstra_ranges.cpp

@@ -25,7 +25,7 @@ int main() {
     std::cout << "=== Dijkstra's Algorithm with C++20 Ranges ===\n\n";
 
     // Create a weighted graph
-    adjacency_list<directed_tag, VertexProps, EdgeProps> g(6);
+    simple_adjacency_list<directed_tag, VertexProps, EdgeProps> g(6);
 
     // Set vertex names
     g[0].name = "A";