webserver: decompose on_methods_ under the CCN 10 bar (28 -> 7)

webserver::on_methods_ was a 171-line registration entry point doing
input validation, v1-map find-or-create-shim, atomicity pre-check,
slot installation, v1 insertion across three maps, and v2 3-tier
table mirror (radix vs exact vs regex_, with fresh-insert vs methods-
merge sub-paths). CCN 28.

Decomposed into private member helpers on detail::webserver_impl:

  prepare_or_create_lambda_shim  v1 find-or-create + atomicity pre-check
  commit_handlers_to_shim        install the handler into every slot
  insert_fresh_v1_entries        v1 maps insertion (str + regex tiers)
  upsert_v2_table_entry          v2 3-tier orchestrator
    upsert_v2_param_route          radix tier (read-merge-reinsert)
    insert_fresh_v2_entry          exact / regex_ first-insert
    update_existing_v2_entry       merge methods into existing entry

on_methods_ on webserver now reads as: validate args, build endpoint,
acquire registered_resources_mutex once for the v1 work, release it,
do the v2 work under route_table_mutex_ internally, invalidate cache.
CCN 7. Every new helper sits at CCN <= 7.

Also dedupes the pre-check loop (line 539) vs commit loop (line 558)
duplication flagged by `make lint-duplication` at low minimum-tokens
sensitivity: extracts a file-scope `for_each_requested_method` template
helper that iterates http_method::count_ in enum order (TASK-021's
Allow-header serialization order) and invokes the callback only for
methods set in the requested mask. Both former loops collapse to two-
line callback invocations.

Locking discipline preserved: registered_resources_mutex (unique_lock)
held across the v1 helpers, dropped at end of inner scope; route_table_mutex_
held inside upsert_v2_table_entry only. Lock order is registered_resources
-> route_table -> route_cache, identical to the original.

Verified locally: full `make check`.

scripts/check-complexity.sh CCN_MAX ratcheted 29 -> 23 (the new worst
offender is http_endpoint::http_endpoint at CCN 22).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: etr

scripts/check-complexity.sh

@@ -27,7 +27,7 @@
 set -euo pipefail
 
 REPO_ROOT="$(cd "$(dirname "$0")/.." && pwd)"
-CCN_MAX="${CCN_MAX:-29}"
+CCN_MAX="${CCN_MAX:-23}"
 
 # Prefer the standalone `lizard` entrypoint if it's on PATH; fall back to
 # `python3 -m lizard` which is what `pip install --user lizard` produces

src/httpserver/detail/webserver_impl.hpp

@@ -45,6 +45,7 @@
 #include <atomic>
 #include <cstddef>
 #include <cstring>
+#include <functional>
 #include <list>
 #include <map>
 #include <memory>
@@ -86,6 +87,7 @@ class websocket_handler;
 namespace detail {
 
 struct modded_request;
+class lambda_resource;
 
 // connection_state: per-MHD_Connection arena anchor.
 //
@@ -478,6 +480,39 @@ class webserver_impl {
     MHD_Result materialize_and_queue_response(MHD_Connection* connection,
                                               modded_request* mr);
 
+    // Helpers carved out of webserver::on_methods_ to stay under the
+    // cyclomatic-complexity bar. The orchestrator on_methods_ retains
+    // input validation and the public ordering; everything that
+    // mutates the v1 maps or the v2 3-tier table lives here.
+    //
+    // Caller must hold registered_resources_mutex (unique_lock) for
+    // prepare_or_create_lambda_shim, commit_handlers_to_shim, and
+    // insert_fresh_v1_entries. upsert_v2_table_entry takes
+    // route_table_mutex_ internally.
+    std::shared_ptr<detail::lambda_resource>
+        prepare_or_create_lambda_shim(const detail::http_endpoint& idx,
+                                      method_set methods,
+                                      bool& fresh_out);
+    void commit_handlers_to_shim(detail::lambda_resource& shim,
+                                 method_set methods,
+                                 const std::function<::httpserver::http_response(
+                                     const ::httpserver::http_request&)>& handler);
+    void insert_fresh_v1_entries(const detail::http_endpoint& idx,
+                                 std::shared_ptr<::httpserver::http_resource> shim);
+    void upsert_v2_table_entry(const detail::http_endpoint& idx,
+                               method_set methods,
+                               std::shared_ptr<::httpserver::http_resource> shim,
+                               bool fresh);
+    void upsert_v2_param_route(const std::string& key,
+                               method_set methods,
+                               std::shared_ptr<::httpserver::http_resource> shim);
+    void insert_fresh_v2_entry(const detail::http_endpoint& idx,
+                               method_set methods,
+                               std::shared_ptr<::httpserver::http_resource> shim);
+    void update_existing_v2_entry(const std::string& key,
+                                  method_set methods,
+                                  std::shared_ptr<::httpserver::http_resource> shim);
+
     MHD_Result complete_request(MHD_Connection* connection, modded_request* mr,
                                 const char* version, const char* method);
     struct MHD_Response* get_raw_response_with_fallback(modded_request* mr);