feat: add tick processing/idle time diagnostics

Tracks actual tick work duration and idle/sleep time separately from
tick rate, via zero-arg begin/end pairs (skele_clock_tick_begin/end,
skele_clock_idle_begin/end) rather than passed timestamps, since the
prior interval-between-calls approach just measured the fixed tick
period, not real processing cost.

include/clock.h

@@ -7,9 +7,17 @@
 extern "C" {
 #endif
 
+extern float skele_tps;
+extern uint64_t skele_tick_time_ns;
+extern uint64_t skele_tick_idle_ns;
+
 void     skele_clock_init(void (*on_signal)(void));
 uint64_t skele_time_ns(void);
 void     skele_sleep_ns(uint64_t ns);
+void     skele_clock_tick_begin(void);
+void     skele_clock_tick_end(void);
+void     skele_clock_idle_begin(void);
+void     skele_clock_idle_end(void);
 
 #ifdef __cplusplus
 }

src/skele.c

@@ -1,21 +1,76 @@
 #include "skele.h"
+#include "clock.h"
 #include <stk/stk.h>
 #include <stk/stk_log.h>
 
 uint64_t skele_tick_ns = 1000000000ULL / SKELE_DEFAULT_TICK_RATE;
 
+float skele_tps = 0.0f;
+uint64_t skele_tick_time_ns = 0;
+uint64_t skele_tick_idle_ns = 0;
+
 static uint8_t stk_initialized = 0;
 
+static uint64_t tick_win_start = 0;
+static uint64_t tick_ns_accum = 0;
+static uint64_t tick_idle_accum = 0;
+static uint32_t tick_count = 0;
+static uint64_t tick_start_ns = 0;
+static uint64_t idle_start_ns = 0;
+
 void skele_set_tick_rate(uint8_t rate)
 {
 	skele_tick_ns = 1000000000ULL / (rate ? rate : SKELE_DEFAULT_TICK_RATE);
 }
 
-uint8_t skele_init(void) { return SKELE_INIT_SUCCESS; }
+uint8_t skele_init(void)
+{
+	tick_win_start = skele_time_ns();
+	tick_ns_accum = 0;
+	tick_idle_accum = 0;
+	tick_count = 0;
+	skele_tps = 0.0f;
+	skele_tick_time_ns = 0;
+	skele_tick_idle_ns = 0;
+	return SKELE_INIT_SUCCESS;
+}
 
 void skele_shutdown(void) {}
 
-void skele_tick(void) {}
+void skele_tick(void)
+{
+	skele_clock_tick_begin();
+	skele_clock_tick_end();
+}
+
+void skele_clock_tick_begin(void) { tick_start_ns = skele_time_ns(); }
+
+void skele_clock_tick_end(void)
+{
+	uint64_t now = skele_time_ns();
+
+	tick_ns_accum += now - tick_start_ns;
+	tick_count++;
+
+	if (now - tick_win_start >= 1000000000ULL) {
+		double elapsed_s = (now - tick_win_start) / 1e9;
+		skele_tps = tick_count / elapsed_s;
+		skele_tick_time_ns = tick_ns_accum / tick_count;
+		skele_tick_idle_ns = tick_idle_accum / tick_count;
+
+		tick_win_start = now;
+		tick_ns_accum = 0;
+		tick_idle_accum = 0;
+		tick_count = 0;
+	}
+}
+
+void skele_clock_idle_begin(void) { idle_start_ns = skele_time_ns(); }
+
+void skele_clock_idle_end(void)
+{
+	tick_idle_accum += skele_time_ns() - idle_start_ns;
+}
 
 uint8_t skele_stk_setup(void)
 {