perf: a file view re-reads the file only when a structural change really dropped it

Three tightenings, all measured with the reloads now reported on stderr.

`set_math_channels()` treats an identical list as no change at all. It rebuilt
unconditionally, and a rebuild replaces the buffer and drops its history -- which a file
view then has to re-read from disk. The comparison is the graphs', and it leaves the nodes'
`x`/`y` out deliberately: those are the canvas's own, no op reads them, and a graph that
merely *moved* should not cost the buffer.

`reload_file_view()` fires only when the store is actually empty. A change that really
happened leaves it so in a file view (the rebuild replaces it, and there is no producer to
refill it); one that found nothing to do leaves it full, and reading a 200 MB file again for
that is the waste. `ScopeModel::stored_slots()` is the one-line accessor it needed.

Every reload now says so, because a second read of a file is worth accounting for:

    [udpscope] reloaded <path> after a structural change: 402 samples back

Measured, `--open` a file:

    session with no graphs            0 reloads
    the math probe (3 real changes)   3 reloads, and all the readings stay equal
                                      (`math x2 402 samples vs 402 time slots`)

I had offered this as "one extra read at `--open` startup", and that was wrong: with no
session there is no `apply_math_channels()` call at all, so there was never an extra read
to remove. What the tightenings buy is that a no-op application is now free, and that a
reload cannot happen unless the buffer was really lost. Each *genuine* change still costs
one re-read -- a rebuild drops the history by design, and preserving it across a rebuild is
a model change rather than this one.

src/model.hpp

@@ -281,6 +281,10 @@ class ScopeModel {
   /// evaluated from those, in order, so a math channel may use another one.
   void push_math_sample(const std::vector<f32>& sample);
 
+  /// How many slots the store currently holds. A file view reads it to tell a structural change that
+  /// dropped the buffer (0) from one that could not have (see `reload_file_view()` in ui.cpp).
+  std::uint64_t stored_slots();
+
   /// Pushes one stored slot of a **file** load -- the values, the shared clock and the absolute
   /// clock -- and then the derived channels, in the producer's own order and under the model's own
   /// lock. The loader cannot simply hold the lock and push into `live()` itself: every setter it