feat: 4Hz fan control with gear/cruise-aware clamps; move hot signals to cereal

Fan control rework (thermald → 4Hz):
- DT_TRML 0.5s → 0.25s (thermald loop + fan PID now at 4Hz)
- New clamp rules based on (gear, cruise_engaged, standstill):
    parked                                → 0-100%
    in drive + cruise engaged (any speed) → 30-100%
    in drive + cruise off + standstill    → 10-100%
    in drive + cruise off + moving        → 30-100%
- thermald now reads gearShifter (via carState) and controlsState.enabled,
  passes them to fan_controller.update()
- Removed BENCH_MODE special case — new rules cover bench automatically
- Removed ignition-based branches — gear is the correct signal

System health overlay:
- Subscribed UI to peripheralState so we can read fanSpeedRpm
- Added FAN row: actual fan% (RPM / 65) to sit alongside LAG/DROP/TEMP/CPU/MEM.
  Shows the real fan output vs. what the PID is asking for.

Migrate hot signals from paramsMemory to cereal (frogpilotCarControl):
- Added latRequested @3 and noLatLaneChange @4 to FrogPilotCarControl schema
- controlsd sets FPCC.latRequested / FPCC.noLatLaneChange (send-on-change
  already gates the IPC)
- modeld reads from sm['frogpilotCarControl'] (added to its subscribers)
  instead of paramsMemory (saves ~20 file-read syscalls/sec)
- carcontroller reads from frogpilot_variables (set in-process by controlsd)
  instead of paramsMemory (saves ~100 file-read syscalls/sec in 100Hz path).
  Dropped carcontroller's now-unused Params instance and import.
- UI (ui.cc, onroad.cc) reads from sm['frogpilotCarControl'].noLatLaneChange
- Removed LatRequested and no_lat_lane_change param registrations + defaults

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

selfdrive/controls/controlsd.py

@@ -172,9 +172,8 @@ class Controls:
     self.not_running_prev = None
     self.lat_requested_ts = 0  # CLEARPILOT: timestamp when lat was first requested (ramp-up delay + comm issue suppression)
     self.prev_lat_requested = False
-    self.prev_no_lat_lane_change = None  # CLEARPILOT: gate no_lat_lane_change write on change
     # CLEARPILOT: gate frogpilotCarControl send on change (3 static bools, was publishing 100Hz)
-    self._prev_fpcc = (None, None, None)
+    self._prev_fpcc = (None, None, None, None, None)
     self._last_fpcc_send_frame = 0
     self.steer_limited = False
     self.desired_curvature = 0.0
@@ -702,12 +701,12 @@ class Controls:
 
     # CLEARPILOT: tell modeld early so it can ramp to 20fps, then delay latActive by
     # 250ms (5 frames at 20fps) so downstream services stabilize before steering engages.
+    # latRequested is now on frogpilotCarControl (cereal) — see update_frogpilot_variables.
     now_ts = time.monotonic()
-    if lat_requested != self.prev_lat_requested:
-      self.params_memory.put_bool("LatRequested", lat_requested)
-      if lat_requested:
-        self.lat_requested_ts = now_ts
+    if lat_requested and not self.prev_lat_requested:
+      self.lat_requested_ts = now_ts
     self.prev_lat_requested = lat_requested
+    self.FPCC.latRequested = lat_requested
     CC.latActive = lat_requested and (now_ts - self.lat_requested_ts) >= 0.25
     CC.longActive = self.enabled and not self.events.contains(ET.OVERRIDE_LONGITUDINAL) and self.CP.openpilotLongitudinalControl
 
@@ -726,10 +725,10 @@ class Controls:
     no_lat_lane_change = model_v2.meta.laneChangeState == LaneChangeState.laneChangeStarting and clearpilot_disable_lat_on_lane_change
     if no_lat_lane_change:
       CC.latActive = False
-    # CLEARPILOT: only write on change — per-cycle atomic writes were eating ~15% CPU
-    if no_lat_lane_change != self.prev_no_lat_lane_change:
-      self.params_memory.put_bool("no_lat_lane_change", no_lat_lane_change)
-      self.prev_no_lat_lane_change = no_lat_lane_change
+    # CLEARPILOT: noLatLaneChange now lives on frogpilotCarControl (see update_frogpilot_variables).
+    # Also mirrored to frogpilot_variables so in-process carcontroller reads it without IPC.
+    self.FPCC.noLatLaneChange = no_lat_lane_change
+    self.frogpilot_variables.no_lat_lane_change = no_lat_lane_change
 
     if CS.leftBlinker or CS.rightBlinker:
       self.last_blinker_frame = self.sm.frame
@@ -1211,9 +1210,11 @@ class Controls:
 
     self.FPCC.trafficModeActive = self.frogpilot_variables.traffic_mode and self.params_memory.get_bool("TrafficModeActive")
 
-    # CLEARPILOT: send only when one of the 3 fields changes, with 1Hz keepalive
+    # CLEARPILOT: send only when any field changes, with 1Hz keepalive
     # Saves ~7ms/sec of capnp+zmq work (was sending 100Hz despite static contents)
-    fpcc_tuple = (self.FPCC.alwaysOnLateral, self.FPCC.speedLimitChanged, self.FPCC.trafficModeActive)
+    # latRequested and noLatLaneChange are edge-triggered too (rare flips)
+    fpcc_tuple = (self.FPCC.alwaysOnLateral, self.FPCC.speedLimitChanged, self.FPCC.trafficModeActive,
+                  self.FPCC.latRequested, self.FPCC.noLatLaneChange)
     if fpcc_tuple != self._prev_fpcc or (self.sm.frame - self._last_fpcc_send_frame) >= 100:
       fpcc_send = messaging.new_message('frogpilotCarControl')
       fpcc_send.valid = CS.canValid