Updates `actions/checkout` from 6.0.1 to 6.0.2
Updates `github/codeql-action` from 4.31.9 to 4.32.0
Updates `actions/upload-artifact` from 5.0.0 to 6.0.0

Updates `platforms` from 1.0.0 to 1.1.0
Updates `rules_cc` from 0.2.14 to 0.2.18

* ci: adding scheduled runs for system-tests

* test

* Fix dev call

* Remove test

* Remove API key

* Cleanup

…m Tests (#325)

…() (#326)

* fix(telemetry): refactor to shared_ptr and add deterministic shutdown()

Refactors Telemetry to be heap-allocated via a shared_ptr
(enable_shared_from_this + factory create()). Scheduled-task callbacks
now capture a weak_from_this() so they become no-ops automatically once
the object is no longer reachable. Move semantics are removed.

Adds a shutdown() function that cancels scheduled tasks, sends the
app-closing payload, and releases the HTTP client. After the call, all
HTTP sending becomes a no-op: send_payload() snapshots http_client_
under http_client_mutex_ and returns early if null. http_client_ is
reset under the same mutex in shutdown(), so any concurrent call that
already holds a live snapshot completes cleanly while new calls
short-circuit. If this is the last shared_ptr to the client, the
background Curl thread is joined at that point.

Rationale: shutdown() cannot guarantee that, after it returns, there
are no in-flight HTTP callbacks still holding a reference to Telemetry
state. Using a shared_ptr ensures any late callback finds a dead
weak_ptr and short-circuits instead of accessing a destroyed object.

The load-bearing weak_from_this() captures are the on_response and
on_error lambdas inside send_payload(). Those run on CurlImpl's
independent event_loop_ thread (via handle_message()), which has no
blocking-cancel mechanism. app_closing() calls drain() with a 2-second
deadline, so if the agent is slow, requests can still be in flight on
the curl thread after shutdown() returns. The weak.lock() guard is what
prevents a use-after-free in that window.

The weak_from_this() captures in the scheduled-task callbacks
(schedule_tasks()) are defense-in-depth for a different concern:
ThreadedEventScheduler's cancel() blocks until any in-progress
callback finishes, making those captures redundant against the
threaded scheduler. However, the EventScheduler interface does not
mandate a blocking cancel(), so the captures guard against
non-blocking implementations where a callback could otherwise touch
Telemetry state after it has been torn down.

Also fixes a race in test_span.cpp: disabling telemetry there prevents
app_started() from posting to the Curl background thread, which would
otherwise fail to reach the (absent) agent asynchronously and call
log_error() on the shared MockLogger, racing against the
error_count == 0 assertion.

Co-Authored-By: Claude Sonnet 4.6 <[email protected]>

* fix comment wording

* run clang-format

---------

Co-authored-by: Claude Sonnet 4.6 <[email protected]>

…on to avoid crash (#328)