This demo shows an app with UI options to:

1. Reset DockState to a default.
2. Snapshot DockState, and then reload it.
3. Export DockState in ron format and then import it.
4. All state is stored within the DockLayoutDemo struct, which means it all serializes to disk so nothing is lost on save/reload.

I think this code is not structured in a normal way for egui_dock, and I suspect it will run into issues later because of it, but it does work for this demo.

My understanding is that egui_dock has a rather hard requirement on separating DockState and the rest of the app's context. For example, in a canonical example, they are entirely separate fields:

struct MyApp {
    context: MyContext,
    tree: DockState<String>,
}
impl TabViewer for MyContext {
  // implements the `ui` method that renders a UI based only on the app context. It cannot use DockState.
}
impl eframe::App for MyApp {
    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Fram
                // Note that the app state and DockState are kept entirely separate.
                DockArea::new(&mut self.tree)
                    .show_inside(ui, &mut self.context);
  }
}

I'd like the user to be able to reset, save, and load DockState. It needs to be triggered from the UI, but this means that TabViewer needs access to DockState. I ended up with:

struct DockLayoutDemo {
    // it has some nested fields, but the important part is that it contains: DockState<TabName>
    // as well as all of the other app state.
}
impl TabViewer for DockLayoutDemo {
  // implements the `ui` method. Since it has access to DockState, it can have conditional logic based on it.
  // For example, in the `add_popup`, it can choose to say that there are no remaining tabs to open.
}
impl eframe::App for MyApp {
    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Fram
        // It wouldn't be possible to pass dock state directly into DockArea::new since that would result
        // in two mutable references to `self`. Instead, copy it and copy it back afterwards.
        let mut dock_state = self.ui_state.dock.state.clone();
        DockArea::new(&mut dock_state).show_inside(ui, self);
        self.ui_state.dock.state = dock_state;
        // This approach has a bad code smell because of the clone, and because any changes to `self.ui.dock.state` get overwritten by whatever happened in DockArea.
        // It also requires operations from the UI to be handled here, rather than directly in the rendering code like egui normally works.
        for (tab_to_add, surface, node) in self.ui_state.dock.pending_add_tab.drain(..) {
            self.ui_state.dock.state[surface].set_focused_node(node);
            self.ui_state.dock.state[surface].push_to_focused_leaf(tab_to_add);
        }
  }
}

I worked on this for a few more hours. This new demo has a lot more error handling, a simplified UI, and more importantly it resolved the architectural issue that the previous demo had. I'm posting it in a new gist:
https://gist.github.com/Omustardo/6bf42b80123dd07cd0375cc3fdd26286