Extract DB records from compound state tuples: simple atoms (Phase 5 final)

[brianmay]

Summary

This PR completes the state machine simplification by replacing compound state tuples like {:driving, status, %Log.Drive{}}, {:charging, %Log.ChargingProcess{}}, and {:updating, %Log.Update{}} with simple atoms (:driving, :charging, :updating). DB records and sub-states are stored in Data struct fields.

Changes (4 commits)

Commit 1: Add preparatory fields to Data struct

Adds current_drive, current_charging_process, current_update, and driving_status fields.

Commit 2: Populate Data struct fields in parallel with compound state tuples

Every transition into a compound state now also updates the corresponding struct fields.

Commit 3: Migrate compound state reads to struct field guards

Replaces pattern-match reads with guards on the struct fields.

Commit 4: Replace compound state tuples with simple atoms throughout state machine

This is the main simplification commit. After this:

• The GenState state is always a simple atom
• {:driving, status, drive} → :driving (status in data.driving_status, drive in data.current_drive)
• {:charging, cproc} → :charging (cproc in data.current_charging_process)
• {:updating, update} → :updating (update in data.current_update)

Key changes in this commit:

• All 12 next_state positions now use simple atoms
• Driving sub-state machine (available → unavailable → offline) is tracked in data.driving_status instead of the state tuple's second element
• All driving handlers match :driving with guards on driving_status
• suspend_logging, fetch/can_fall_asleep, and fetch/reachable all use simple atom matching
• Summary module updated to handle the new state format

Refactoring sequence (complete!)

1. ✅ Replace fake_online_state integers with pre_online_check atoms
2. ✅ Add struct fields + populate them + migrate reads
3. ✅ This PR: Replace compound states with simple atoms

Before vs After

Before (hard to read):

def handle_event(:internal, {:update, {:offline, _}}, {:driving, {:unavailable, n}, drv}, ...)
def handle_event(:internal, {:update, {:offline, _}}, {:driving, {:offline, last}, drive}, ...)
def handle_event(:info, {:stream, %Stream.Data{} = stream_data}, {:driving, status, drv}, ...)

After (clean):

def handle_event(:internal, {:update, {:offline, _}}, :driving, %Data{driving_status: {:unavailable, n}}) do ...
def handle_event(:internal, {:update, {:offline, _}}, :driving, %Data{driving_status: {:offline, last}}) do ...
def handle_event(:info, {:stream, %Stream.Data{}}, :driving, %Data{driving_status: :available, current_drive: drv}) do ...

Testing

All commits are no-behaviour-change mechanical refactors. Existing tests pass.

[brianmay]

This is only the first phase so far, we haven't seen the simplification to the compound state tuples yet. That will come later.

[brianmay]

As before, this was done with AI. It was going to make one big pull request, then we agreed that breaking it up might be better.

[brianmay]

I decided to do the full refactor in one pull request. While this the PR more complicated, don't think you can really review this probably unless you can see the entire picture.

The steps are still there, but as separate commits. Which probably should stay as separate commits.

Key questions before merging:

1. Does this make things simpler and easier to understand?

I think by making the state an enum only and putting state data into the data variable we have made it easier to understand. If anyone disagrees, feel free to speak out :-)

2. Is it correct?

It looks OK to me... Although certainly is scope for errors to creep in. Guess next step will be to test this.

[brianmay]

I spotted a place where the logic had been changed and was more complicated then required. Fixed now.