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/ui.cpp

@@ -4190,6 +4190,10 @@ gboolean on_app_key_pressed(GtkEventControllerKey*, guint keyval, guint, GdkModi
 /// math once the set is in place.
 bool reload_file_view(App& app) {
   if (!app.replaying && app.model->config().open_waveform.empty()) return false;
+  // Nothing to restore: a change that really happened leaves the store empty in a file view -- the
+  // rebuild replaces it and there is no producer to refill it -- while one that found nothing to do
+  // leaves it full. Reading the file again for the second kind is the waste this avoids.
+  if (app.model->stored_slots() > 0) return false;
   const std::string path =
       !app.waveform_name.empty() ? app.waveform_name : app.model->config().open_waveform;
   if (path.empty()) return false;
@@ -4199,6 +4203,10 @@ bool reload_file_view(App& app) {
     set_notice(app, "cannot reload " + path + " after the change: " + error, 6);
     return false;
   }
+  // Said out loud because it is the one place a file is read twice: a structural change really did
+  // drop the buffer, and the file is the only thing that can put it back.
+  std::fprintf(stderr, "[udpscope] reloaded %s after a structural change: %llu samples back\n",
+               path.c_str(), static_cast<unsigned long long>(report.samples));
   return true;
 }