menu: wire parent_menu at build time and fix ESC dismiss

Three related fixes for submenu dismiss behavior in PopupMenu:

1. Wire parent_menu in PopupMenu::build (one-shot at construction).
   Submenus added via PopupMenuItem::submenu(label, entity) — the data
   constructor — can't reach the parent's entity at build time, so they
   land with parent_menu = None. After the user closure populates the
   menu, iterate menu_items once and wire any orphan submenus to point
   at the menu being built. Zero per-frame cost, handles arbitrary
   nesting because every submenu also goes through PopupMenu::build.

   This was previously done in Render::render which iterated and
   notified every frame — replaced with the one-shot approach.

2. Fix ESC not closing menus when a submenu is open. When a submenu is
   opened by hover, the parent menu retains focus. Pressing ESC hit the
   parent's dismiss(), which bailed out early because active_submenu()
   was Some. Split dismiss into dismiss (Cancel handler — clears the
   active submenu first) and dismiss_menu (internal — propagates up the
   chain).

3. Guard handle_dismiss for submenu clicks. handle_dismiss
   (click-outside) now returns early if a submenu is active. Without
   this, clicking a submenu item triggers the parent's
   on_mouse_down_out, tearing down the submenu before the item's
   on_click fires.

Fixes #2229

Author: boboshan

crates/ui/src/menu/popup_menu.rs

@@ -321,7 +321,24 @@ impl PopupMenu {
         cx: &mut App,
         f: impl FnOnce(Self, &mut Window, &mut Context<PopupMenu>) -> Self,
     ) -> Entity<Self> {
-        cx.new(|cx| f(Self::new(cx), window, cx))
+        cx.new(|cx| {
+            let menu = f(Self::new(cx), window, cx);
+            // Wire parent_menu on any submenu children that were added via
+            // the PopupMenuItem::submenu(label, entity) data constructor —
+            // unlike PopupMenu::submenu() (the builder), it can't reach the
+            // parent's entity at construction time. Runs once per menu build.
+            let parent = cx.entity().downgrade();
+            for item in &menu.menu_items {
+                if let PopupMenuItem::Submenu { menu: sub, .. } = item {
+                    sub.update(cx, |sub, _| {
+                        if sub.parent_menu.is_none() {
+                            sub.parent_menu = Some(parent.clone());
+                        }
+                    });
+                }
+            }
+            menu
+        })
     }
 
     /// Set the focus handle of Entity to handle actions.
@@ -753,7 +770,7 @@ impl PopupMenu {
                             self.dispatch_confirm_action(action, window, cx);
                         }
 
-                        self.dismiss(&Cancel, window, cx)
+                        self.dismiss_menu(window, cx)
                     }
                     Some(PopupMenuItem::ElementItem {
                         handler, action, ..
@@ -763,7 +780,7 @@ impl PopupMenu {
                         } else if let Some(action) = action.as_ref() {
                             self.dispatch_confirm_action(action, window, cx);
                         }
-                        self.dismiss(&Cancel, window, cx)
+                        self.dismiss_menu(window, cx)
                     }
                     _ => {}
                 }
@@ -932,11 +949,17 @@ impl PopupMenu {
         }
     }
 
+    /// Cancel/ESC action handler. Closes any active submenu first, then
+    /// dismisses the entire menu chain. This ensures ESC works even when a
+    /// hover-opened submenu is visible and the parent retains focus.
     fn dismiss(&mut self, _: &Cancel, window: &mut Window, cx: &mut Context<Self>) {
-        if self.active_submenu().is_some() {
-            return;
-        }
+        self.selected_index = None;
+        self.dismiss_menu(window, cx);
+    }
 
+    /// Internal dismiss: emits DismissEvent and propagates up the parent chain.
+    /// Used by `confirm` (item click) and `handle_dismiss` (click-outside).
+    fn dismiss_menu(&mut self, window: &mut Window, cx: &mut Context<Self>) {
         cx.emit(DismissEvent);
 
         // Focus back to the previous focused handle.
@@ -951,7 +974,7 @@ impl PopupMenu {
         // Dismiss parent menu, when this menu is dismissed
         _ = parent_menu.update(cx, |view, cx| {
             view.selected_index = None;
-            view.dismiss(&Cancel, window, cx);
+            view.dismiss_menu(window, cx);
         });
     }
 
@@ -970,7 +993,15 @@ impl PopupMenu {
             }
         }
 
-        self.dismiss(&Cancel, window, cx);
+        // Do not dismiss if a submenu is active — the submenu handles its
+        // own mouse-down-out. Without this guard, clicking a submenu item
+        // would trigger the parent's on_mouse_down_out and tear down the
+        // submenu before the item's on_click fires.
+        if self.active_submenu().is_some() {
+            return;
+        }
+
+        self.dismiss_menu(window, cx);
     }
 
     fn on_mouse_down_out(