feat: add CLI argument parser with ASIO duration timer

Adds support for `--duration <seconds>` (and `--help`) to
automatically terminate after a set time. Useful for testing,
CI, and agent runs where the default infinite loop is
problematic.

Uses `asio::steady_timer` + `async_wait` for the timeout
(unified with the existing signal handling under one
io_context). The `process_signals` lambda was restored as it
looks nicer.

Combines what were 4 incremental commits into one (the
separate window refactor from earlier remains). Updated
cuber.cpp and includes.

cuber.cpp

@@ -1,15 +1,35 @@
 #define GLFW_INCLUDE_NONE
 
 #include <csignal>
+#include <chrono>
+#include <string>
+#include <string_view>
 
 #include "GLFW/glfw3.h"
 #include "asio.hpp"
+#include "asio/steady_timer.hpp"
+#include "fmt/std.h"
 
 #include "cbt/window.hpp"
 #include "cbt/opengl/context.hpp"
 #include "scenes/cube.hpp"
 
-auto main(int, char const*[]) -> int {
+auto main(int argc, char const* argv[]) -> int {
+    float max_duration_seconds = 0.0f;
+
+    for (int i = 1; i < argc; ++i) {
+        std::string_view arg = argv[i];
+        if (arg == "--help" || arg == "-h") {
+            fmt::print("Usage: {} [--duration <seconds>] [--help|-h]\n", argv[0]);
+            fmt::print("  --duration <seconds>  Auto-terminate after N seconds (for testing/CI)\n");
+            return 0;
+        }
+        if (arg == "--duration" && i + 1 < argc) {
+            max_duration_seconds = std::stof(std::string(argv[++i]));
+            continue;
+        }
+    }
+
     auto win = cbt::window("cuber", 1280, 720);
 
     if (!win.valid()) {
@@ -27,7 +47,7 @@ auto main(int, char const*[]) -> int {
         return 1;
     }
 
-    // signal handling
+    // signal handling + optional duration timer (via ASIO)
     asio::io_context io;
     asio::signal_set signals(io, SIGINT, SIGTERM);
     bool quit = false;
@@ -37,6 +57,17 @@ auto main(int, char const*[]) -> int {
         io.stop();
     });
 
+    asio::steady_timer duration_timer(io);
+    if (max_duration_seconds > 0.0f) {
+        duration_timer.expires_after(std::chrono::milliseconds(
+            static_cast<long long>(max_duration_seconds * 1000.0f)));
+        duration_timer.async_wait([&](auto ec) {
+            if (!ec) {
+                quit = true;
+            }
+        });
+    }
+
     auto process_signals = [&]() -> void {
         while (io.poll()) {}
     };
@@ -47,11 +78,11 @@ auto main(int, char const*[]) -> int {
     while (!win.should_close()) {
         process_signals();
 
+        auto now = std::chrono::steady_clock::now();
         if (quit || glfwGetKey(win.raw(), GLFW_KEY_Q) == GLFW_PRESS) {
             break;
         }
 
-        auto now = std::chrono::steady_clock::now();
         auto dt = std::chrono::duration<float>(now - prev).count();
         prev = now;