fix: the math editor's body was a child of the window, not of the box above it

Moving the editor's frame into math-editor.ui left `math_body` and `math_actions` as
<child> elements of the *window* rather than of `math_outer`, because those edits were
anchored on the file's tail and closed the outer box two elements early. A GtkWindow
takes exactly one default <child>, so nothing failed loudly: the body -- with the canvas
and the parameter form inside it -- was left parentless, visible but never mapped, 0x0,
drawing nothing. Two symptoms, one cause: the canvas is blank, and the window is sized
around the head row and the buttons alone.

Measured against the pre-move revision in a worktree, same probe, same environment:
before this fix `canvas=0x0 mapped=0 window=756x940`; after it `canvas=420x836 mapped=1
window=938x940`, which is the old revision's own reading exactly.

It survived because that slice's probe read the editor's *values* (nodes, gain, output,
name, unit) and nothing about its structure. Every other panel moved that day has a
structural reading -- `controls_inside=13/13`, `nested=1`, `labels=2 list=1` -- and none
of them was affected. `[math-probe] editor frame:` is that reading now: the canvas's
allocation, its mapped state, and whether the canvas and the name entry are inside the
dialog at all, delayed 500 ms because an allocation only exists after a layout. In the
broken build it read `0x0 mapped=0 in_dialog=0`.

check_ui passes both files: the XML was valid and every property type-checked.

src/ui/math-editor.ui

@@ -46,8 +46,6 @@
             </child>
           </object>
         </child>
-      </object>
-    </child>
     <child>
       <object class="GtkBox" id="math_body">
         <property name="orientation">horizontal</property>
@@ -80,5 +78,7 @@
         </child>
       </object>
     </child>
+      </object>
+    </child>
   </object>
 </interface>

src/ui_probe.cpp

@@ -386,6 +386,35 @@ gboolean math_probe(gpointer user) {
       if (ed->gain != nullptr) gtk_spin_button_set_value(GTK_SPIN_BUTTON(ed->gain), 2.0);
       if (ed->offset != nullptr) gtk_spin_button_set_value(GTK_SPIN_BUTTON(ed->offset), 0.0);
       on_math_param_changed(nullptr, ed);
+      // The frame, structurally: the canvas being *in* the dialog and given an allocation. A `.ui`
+      // mistake this has already paid for once -- `math_body` nested under the window instead of the
+      // outer box -- leaves the canvas visible but parentless: it never maps, stays 0x0 and draws
+      // nothing, which a user reads as "the editor opens and the canvas is blank". The values below
+      // cannot see that, and the reading is delayed because an allocation only exists after a layout.
+      g_timeout_add(500, +[](gpointer u) -> gboolean {
+        App* app = static_cast<App*>(u);
+        if (app->math_dialog == nullptr) {
+          std::fprintf(stderr, "[math-probe] editor frame: (dialog closed before the reading)\n");
+          return G_SOURCE_REMOVE;
+        }
+        MathDialog* m = static_cast<MathDialog*>(
+            g_object_get_data(G_OBJECT(app->math_dialog), "udpscope-math-dialog"));
+        if (m == nullptr) return G_SOURCE_REMOVE;
+        const auto in_dialog = [app](GtkWidget* w) {
+          for (GtkWidget* p = w; p != nullptr; p = gtk_widget_get_parent(p)) {
+            if (p == app->math_dialog) return 1;
+          }
+          return 0;
+        };
+        std::fprintf(stderr,
+                     "[math-probe] editor frame: canvas=%dx%d mapped=%d in_dialog=%d "
+                     "name_in_dialog=%d\n",
+                     m->canvas != nullptr ? gtk_widget_get_width(m->canvas) : -1,
+                     m->canvas != nullptr ? gtk_widget_get_height(m->canvas) : -1,
+                     m->canvas != nullptr ? gtk_widget_get_mapped(m->canvas) : -1,
+                     in_dialog(m->canvas), in_dialog(m->name));
+        return G_SOURCE_REMOVE;
+      }, a);
       const std::size_t built = ed->nodes.size();
       const double gain_read = ed->nodes.empty() ? 0.0 : ed->nodes.back().gain;
       const double offset_read = ed->nodes.empty() ? 0.0 : ed->nodes.back().offset;