Redesign approach for CPU usage tracking

The previous implementation maintained three exponential moving averages
(1/5/15-minute) of CPU busy-fraction, sampled every 5 seconds. This had
two problems:

1. Wrong semantics: the metric was labelled "load_avg" (a Unix concept
   measuring run-queue depth), but the tracker actually measures CPU
   busy-time as a fraction of FreeRTOS ticks — i.e. utilization, not
   load.  The name was misleading.

2. Poor responsiveness: the 1-minute EMA (DECAY = exp(-5/60) ≈ 0.920)
   has a ~60-second time constant.  On a live web panel, this made the
   metric appear frozen, especially during short bursts of activity
   (e.g. an HTTP request from the panel itself).

This commit replaces the EMA with a 64-sample simple moving average
(SMA) over a compact uint8_t circular buffer. The sample interval is
60 s / 64 = 937,500 µs, so the window covers exactly 60 seconds:

Algorithm:
- Every 937,500 µs (= 60 s / 64), the FreeRTOS tick delta (busy vs
  idle ticks on core 0) is computed and stored as a uint8_t
  (0–255 = 0–100% utilization).
- The circular buffer holds 64 samples, spanning exactly 60 seconds
  (64 × 937,500 µs = 60,000,000 µs). The timer interval is derived
  directly from the window size: 60 000 000 / SMA_WINDOW µs.
- The index wraps with a bitwise AND (& 63) instead of modulo, since
  64 is a power of 2.
- The running sum is a uint16_t (max 64 × 255 = 16 320, fits easily).
- The result _sma_avg is a volatile float written atomically by the
  esp_timer task (core 0) and read from the main loop (core 1).
  No spinlock is needed: on Xtensa LX7, a 32-bit aligned float store
  is a single instruction.

The 60-second window smooths out short bursts (e.g. WiFi/HTTP spikes)
while reacting to sustained load changes within ~10–15 seconds.

Naming:
- The public API is now getCore0Util() returning a float in [0.0, 1.0].
  The name explicitly identifies which core is measured (core 0, which
  runs WiFi, MQTT, HTTP, and LwIP — see task_pinning.c).
- JSON keys: "load_avg" (array) → "core0_util" (scalar float, percent)
- HistorySample field: load_avg1_pct → core0_util_pct
- StatsHistory series key: "cpu_load" → "core0_util"
- Web panel label: "Load Avg" → "Core0 Util"

The history snapshot (once per minute) reads the same _sma_avg value,
which at that point represents the rolling average of the last 60
seconds — exactly one history interval.

arch/esp32/CPUUsageTracker.cpp

@@ -6,7 +6,7 @@ volatile uint32_t CPUUsageTracker::s_idle_ticks = 0;
 volatile uint32_t CPUUsageTracker::s_busy_ticks = 0;
 TaskHandle_t      CPUUsageTracker::s_idle_handle = nullptr;
 
-void IRAM_ATTR CPUUsageTracker::s_tick_hook() {   // ← was CPUsageTracker (typo)
+void IRAM_ATTR CPUUsageTracker::s_tick_hook() {
   if (xTaskGetCurrentTaskHandle() == s_idle_handle) {
     s_idle_ticks++;
   } else {
@@ -15,23 +15,26 @@ void IRAM_ATTR CPUUsageTracker::s_tick_hook() {   // ← was CPUsageTracker (typ
 }
 
 void CPUUsageTracker::s_sample_cb(void* arg) {
-  static_cast<CPUUsageTracker*>(arg)->_onSample();  // ← was CpuUsageTracker (old name)
+  static_cast<CPUUsageTracker*>(arg)->_onSample();
 }
 
 void CPUUsageTracker::_onSample() {
-  uint32_t busy = s_busy_ticks;
-  uint32_t idle = s_idle_ticks;
-  uint32_t db = busy - _last_busy;
-  uint32_t di = idle - _last_idle;
+  const uint32_t busy = s_busy_ticks;
+  const uint32_t idle = s_idle_ticks;
+  const uint32_t db = busy - _last_busy;
+  const uint32_t di = idle - _last_idle;
   _last_busy = busy;
   _last_idle = idle;
 
-  uint32_t total = db + di;
-  float sample = (total > 0) ? (float)db / total : 0.0f;
+  const uint32_t total = db + di;
+  const float sample = (total > 0) ? (float)db / (float)total : 0.0f;
 
-  _avg1  = DECAY1  * _avg1  + (1.0f - DECAY1)  * sample;
-  _avg5  = DECAY5  * _avg5  + (1.0f - DECAY5)  * sample;
-  _avg15 = DECAY15 * _avg15 + (1.0f - DECAY15) * sample;
+  const uint8_t s8 = (uint8_t)(sample * 255.0f + 0.5f);
+  _sma_sum -= _sma_buf[_sma_idx];
+  _sma_buf[_sma_idx] = s8;
+  _sma_sum += s8;
+  _sma_idx = (_sma_idx + 1) & (SMA_WINDOW - 1);
+  _sma_avg = (float)_sma_sum * (1.0f / (SMA_WINDOW * 255.0f));
 }
 
 void CPUUsageTracker::begin() {
@@ -42,10 +45,10 @@ void CPUUsageTracker::begin() {
     .callback        = s_sample_cb,
     .arg             = this,
     .dispatch_method = ESP_TIMER_TASK,
-    .name            = "cpu_avg"
+    .name            = "cpu_sample"
   };
   esp_timer_create(&args, &_timer);
-  esp_timer_start_periodic(_timer, 5000000ULL);  // 5 seconds
+  esp_timer_start_periodic(_timer, 60000000ULL / SMA_WINDOW);  // SMA_WINDOW samples per minute
 }
 
 #endif