TASK-023: smart-pointer register_resource overloads (GREEN)

Replace the raw-pointer register_resource overload with two
smart-pointer overloads expressing ownership at the call site:

  void register_resource(const std::string& path,
                         std::unique_ptr<T> res,
                         bool family = false);   // T derived from http_resource
  void register_resource(const std::string& path,
                         std::shared_ptr<http_resource> res,
                         bool family = false);

Why two:
  - unique_ptr: the webserver takes sole ownership; resource dtor runs
    on webserver destruction or unregister_resource. This matches the
    common case where the caller has no further use for the resource.
  - shared_ptr: caller and webserver share ownership; useful when the
    caller wants to mutate or query the resource after registration.
  - The unique_ptr overload is templated over the derived type so that
    `register_resource(path, std::make_unique<my_resource>())` resolves
    unambiguously without competing with the shared_ptr overload via
    an implicit unique-to-shared conversion.

Internal storage in webserver_impl now holds shared_ptr<http_resource>
in all three route-table maps and the route_cache_entry. The dispatch
path (finalize_answer) holds a shared_ptr copy across the rendering
call, closing a latent race where a concurrent unregister_resource
could invalidate a raw pointer mid-call.

Return type changes from bool to void. Duplicate registration now
throws std::invalid_argument (replaces v1's silent `return false`).
This is the safer interpretation: a moved-in unique_ptr would be
destroyed inside the conversion to shared_ptr before the duplicate
check runs, so a soft-fail return value would leave the caller with
no way to recover the resource. Throwing surfaces the failure.

Migration:
  - All 38 examples now use std::make_shared<resource_type>() at the
    call site. Where the local resource was used to call mutators
    (disallow_all, set_allowing) before registration, those calls now
    use ->.
  - Integration tests use a small as_shared() test-only helper that
    wraps a stack-local http_resource& in a shared_ptr with a no-op
    deleter, preserving the established "declare resource on stack,
    pass to register_resource" pattern across ~127 call sites.
  - The duplicate-detection tests in basic.cpp and ws_start_stop.cpp
    are rewritten to use LT_CHECK_THROW, asserting the new throw
    semantics.

Acceptance criteria:
  - `auto r = std::make_unique<my_resource>(); ws.register_resource(
    "/foo", std::move(r));` compiles and serves: covered by
    webserver_register_smartptr_test.cpp::unique_ptr_overload_compiles_and_serves.
  - The raw-pointer overload no longer exists in the public header:
    enforced by has_raw_register_resource SFINAE static_assert.
  - A test verifies the resource destructor runs when the webserver is
    destroyed: webserver_register_smartptr_test.cpp::
    unique_ptr_dtor_runs_on_webserver_destruction.
  - All 33 tests pass (release and debug builds).

Author: etr

examples/allowing_disallowing_methods.cpp

@@ -32,10 +32,10 @@ class hello_world_resource : public httpserver::http_resource {
 int main() {
     httpserver::webserver ws = httpserver::create_webserver(8080);
 
-    hello_world_resource hwr;
-    hwr.disallow_all();
-    hwr.set_allowing(httpserver::http_method::get, true);
-    ws.register_resource("/hello", &hwr);
+    auto hwr = std::make_shared<hello_world_resource>();
+    hwr->disallow_all();
+    hwr->set_allowing(httpserver::http_method::get, true);
+    ws.register_resource("/hello", hwr);
     ws.start(true);
 
     return 0;

examples/args_processing.cpp

@@ -89,8 +89,8 @@ class args_resource : public httpserver::http_resource {
 int main() {
     httpserver::webserver ws = httpserver::create_webserver(8080);
 
-    args_resource ar;
-    ws.register_resource("/args", &ar);
+    auto ar = std::make_shared<args_resource>();
+    ws.register_resource("/args", ar);
 
     std::cout << "Server running on http://localhost:8080/args\n";
     std::cout << "Try: http://localhost:8080/args?name=john&age=30\n";

examples/basic_authentication.cpp

@@ -38,8 +38,8 @@ class user_pass_resource : public httpserver::http_resource {
 int main() {
     httpserver::webserver ws = httpserver::create_webserver(8080);
 
-    user_pass_resource hwr;
-    ws.register_resource("/hello", &hwr);
+    auto hwr = std::make_shared<user_pass_resource>();
+    ws.register_resource("/hello", hwr);
     ws.start(true);
 
     return 0;

examples/benchmark_nodelay.cpp

@@ -51,8 +51,8 @@ int main(int argc, char** argv) {
     std::shared_ptr<httpserver::http_response> hello = std::shared_ptr<httpserver::http_response>(new httpserver::http_response(httpserver::http_response::string(BODY)));
     hello->with_header("Server", "libhttpserver");
 
-    hello_world_resource hwr(hello);
-    ws.register_resource(PATH, &hwr, false);
+    auto hwr = std::make_shared<hello_world_resource>(hello);
+    ws.register_resource(PATH, hwr, false);
 
     ws.start(true);
 

examples/benchmark_select.cpp

@@ -50,8 +50,8 @@ int main(int argc, char** argv) {
     std::shared_ptr<httpserver::http_response> hello = std::shared_ptr<httpserver::http_response>(new httpserver::http_response(httpserver::http_response::string(BODY)));
     hello->with_header("Server", "libhttpserver");
 
-    hello_world_resource hwr(hello);
-    ws.register_resource(PATH, &hwr, false);
+    auto hwr = std::make_shared<hello_world_resource>(hello);
+    ws.register_resource(PATH, hwr, false);
 
     ws.start(true);
 

examples/benchmark_threads.cpp

@@ -49,8 +49,8 @@ int main(int argc, char** argv) {
     std::shared_ptr<httpserver::http_response> hello = std::shared_ptr<httpserver::http_response>(new httpserver::http_response(httpserver::http_response::string(BODY)));
     hello->with_header("Server", "libhttpserver");
 
-    hello_world_resource hwr(hello);
-    ws.register_resource(PATH, &hwr, false);
+    auto hwr = std::make_shared<hello_world_resource>(hello);
+    ws.register_resource(PATH, hwr, false);
 
     ws.start(true);
 

examples/binary_buffer_response.cpp

@@ -73,8 +73,8 @@ class image_resource : public httpserver::http_resource {
 int main() {
     httpserver::webserver ws = httpserver::create_webserver(8080);
 
-    image_resource ir;
-    ws.register_resource("/image", &ir);
+    auto ir = std::make_shared<image_resource>();
+    ws.register_resource("/image", ir);
     ws.start(true);
 
     return 0;

examples/centralized_authentication.cpp

@@ -60,11 +60,11 @@ int main() {
         .auth_handler(auth_handler)
         .auth_skip_paths({"/health", "/public/*"});
 
-    hello_resource hello;
-    health_resource health;
+    auto hello = std::make_shared<hello_resource>();
+    auto health = std::make_shared<health_resource>();
 
-    ws.register_resource("/api", &hello);
-    ws.register_resource("/health", &health);
+    ws.register_resource("/api", hello);
+    ws.register_resource("/health", health);
 
     ws.start(true);
 

examples/client_cert_auth.cpp

@@ -154,11 +154,11 @@ int main() {
         .https_mem_cert("server_cert.pem")    // Server certificate
         .https_mem_trust("ca_cert.pem");      // CA certificate for verifying client certs
 
-    secure_resource secure;
-    info_resource info;
+    auto secure = std::make_shared<secure_resource>();
+    auto info = std::make_shared<info_resource>();
 
-    ws.register_resource("/secure", &secure);
-    ws.register_resource("/info", &info);
+    ws.register_resource("/secure", secure);
+    ws.register_resource("/info", info);
 
     std::cout << "Server started. Press Ctrl+C to stop.\n\n";
     std::cout << "Test commands:\n";

examples/custom_access_log.cpp

@@ -39,8 +39,8 @@ int main() {
     httpserver::webserver ws = httpserver::create_webserver(8080)
         .log_access(custom_access_log);
 
-    hello_world_resource hwr;
-    ws.register_resource("/hello", &hwr);
+    auto hwr = std::make_shared<hello_world_resource>();
+    ws.register_resource("/hello", hwr);
     ws.start(true);
 
     return 0;