Add FM ANTCAP antenna calibration: HTTP sweep control + EEPROM persistence

Confirmed live tonight that the Si4684's automatic front-end tuning
(FE_VARM/VARB properties) is measurably suboptimal on this board: a
129-value ANTCAP sweep (0-128, AN851 Appendix A) at four different FM
frequencies found antcap=102 beats auto-tune by +6 to +11 dB RSSI and
+3 to +11 dB SNR everywhere tested, consistent with the front-end
network component mismatch already logged in
docs/si4684-rf-investigation-report.md — the board's actual matching
network differs from the AN851 reference network those auto-tune
constants were derived from, so a fixed empirical override
compensates for a gap the chip's own algorithm can't see.

Wiring, bottom to top:
- Si4684Driver::tuneFm() already took an antCap byte; threaded it
  through core::ITuner::tuneFm() and si4684::Si4684Tuner::tuneFm() as
  a new parameter (default 0 = auto, unchanged behaviour for every
  existing caller).
- TunerService::tuneFm() takes an optional override instead: omitted,
  it falls back to a new defaultFmAntCap_ member so every ordinary FM
  tune (seek, scan, station recall, live UI) benefits automatically
  once calibrated, not just calls that pass antcap explicitly.
- POST /api/tuner/tune gained an optional "antcap" field for sweeping
  live without touching the saved calibration.
- POST /api/tuner/calibrate-antenna commits a sweep result: writes it
  to the 24AA025E48 EEPROM's user-writable region (word address 0x00,
  separate from the factory-locked EUI-48 at 0xFA-0xFF) via a new
  Eeprom24aa::writeFmAntCap()/readFmAntCap() pair, and immediately
  updates the live TunerService default — no reboot needed to take
  effect, though HardwareBootstrap::boot() also loads it at every
  boot so it survives power cycles. Same net::AntennaCalibration
  function-pointer bridge pattern as PhoneStreamSink/BleProvisioning,
  so components/net stays free of eeprom24aa headers.

Verified end to end on hardware: swept and found 102, saved it via
the new endpoint, confirmed the live default changed immediately,
then power-cycled and confirmed the boot log reports "FM ANTCAP
calibration loaded: 102" and a subsequent default tune reflects it.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0178rASQ6ZETPMUamvpoR2KR

Software/components/drivers/eeprom24aa/src/Eeprom24aa.cpp

@@ -15,6 +15,8 @@
 
 #include "driver/i2c_master.h"
 #include "esp_log.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
 
 #include <array>
 
@@ -25,7 +27,13 @@ namespace {
 constexpr char kTag[] = "Eeprom24aa";
 /** EUI-48 word address per Microchip 24AA025E48 datasheet (DS20001191). */
 constexpr std::uint8_t kEui48WordAddress = 0xFAU;
+/** FM ANTCAP calibration byte, in the chip's user-writable region (anywhere
+ *  below the factory-locked 0xFA-0xFF EUI-48 block). */
+constexpr std::uint8_t kFmAntCapWordAddress = 0x00U;
 constexpr int kI2cTimeoutMs = 100;
+/** DS20001191 §"Page Write"/"Byte Write": max write cycle time after STOP
+ *  before the chip acknowledges further I2C traffic. */
+constexpr int kI2cWriteCycleMs = 5;
 
 } // namespace
 
@@ -69,4 +77,75 @@ Eeprom24aa::readDeviceIdentity()
     return core::DeviceIdentity::fromEui48(core::Eui48::fromBytes(payload));
 }
 
+std::expected<std::optional<std::uint8_t>, core::IdentityError>
+Eeprom24aa::readFmAntCap()
+{
+    if (bus_ == nullptr) {
+        return std::unexpected(core::IdentityError::I2cFailed);
+    }
+
+    i2c_device_config_t devCfg = {};
+    devCfg.dev_addr_length = I2C_ADDR_BIT_LEN_7;
+    devCfg.device_address = addr7_;
+    devCfg.scl_speed_hz = 100000;
+
+    i2c_master_dev_handle_t dev = nullptr;
+    if (i2c_master_bus_add_device(bus_, &devCfg, &dev) != ESP_OK) {
+        ESP_LOGW(kTag, "i2c_master_bus_add_device failed");
+        return std::unexpected(core::IdentityError::I2cFailed);
+    }
+
+    const std::uint8_t wordAddress = kFmAntCapWordAddress;
+    std::uint8_t value = 0xFFU;
+    const esp_err_t err = i2c_master_transmit_receive(
+        dev, &wordAddress, 1U, &value, 1U, kI2cTimeoutMs);
+
+    i2c_master_bus_rm_device(dev);
+
+    if (err != ESP_OK) {
+        ESP_LOGW(kTag, "FM ANTCAP read failed (err=0x%x)",
+                 static_cast<unsigned>(err));
+        return std::unexpected(core::IdentityError::ReadFailed);
+    }
+
+    if (value > kFmAntCapMax) {
+        return std::optional<std::uint8_t>{};
+    }
+    return std::optional<std::uint8_t>{value};
+}
+
+std::expected<void, core::IdentityError>
+Eeprom24aa::writeFmAntCap(std::uint8_t value)
+{
+    if (bus_ == nullptr) {
+        return std::unexpected(core::IdentityError::I2cFailed);
+    }
+
+    i2c_device_config_t devCfg = {};
+    devCfg.dev_addr_length = I2C_ADDR_BIT_LEN_7;
+    devCfg.device_address = addr7_;
+    devCfg.scl_speed_hz = 100000;
+
+    i2c_master_dev_handle_t dev = nullptr;
+    if (i2c_master_bus_add_device(bus_, &devCfg, &dev) != ESP_OK) {
+        ESP_LOGW(kTag, "i2c_master_bus_add_device failed");
+        return std::unexpected(core::IdentityError::I2cFailed);
+    }
+
+    const std::array<std::uint8_t, 2> payload = {kFmAntCapWordAddress, value};
+    const esp_err_t err =
+        i2c_master_transmit(dev, payload.data(), payload.size(), kI2cTimeoutMs);
+
+    i2c_master_bus_rm_device(dev);
+
+    if (err != ESP_OK) {
+        ESP_LOGW(kTag, "FM ANTCAP write failed (err=0x%x)",
+                 static_cast<unsigned>(err));
+        return std::unexpected(core::IdentityError::I2cFailed);
+    }
+
+    vTaskDelay(pdMS_TO_TICKS(kI2cWriteCycleMs));
+    return {};
+}
+
 } // namespace eeprom24aa