fix: seed new tab grid with window size, not panel size

add_context fed current.dimension straight into ContextGrid::new for
single-panel tabs. After apply_taffy_layout has run on the old tab,
that dimension carries panel-sized width/height (= window − scaled
margin) with margin zeroed. ContextGrid::new then stored those panel
dimensions as self.width/self.height — its idea of the window size —
and try_update_size subtracted the margin a second time on every
later call.

The break only surfaced once update_scaled_margin started syncing
Taffy's root via try_update_size: closing the original tab so the
freshly-spawned tab survived made resize_top_or_bottom_line(1) ask
Taffy for window_h − 34 − 2 instead of window_h − 2, leaving a tab-
bar-sized gap at the bottom after hide_if_single hid the strip.
Closing the new tab and keeping the original masked it because the
original grid was built with window dimensions at Screen::new and
nothing rewrites self.width/self.height afterwards.

Always rebuild the dimension from the current grid via
grid_dimension(), which composes self.width/self.height (window size)
with the unscaled margin. The split-only branch becomes redundant
since grid_dimension() already produces the correct value for both
single-panel and multi-panel grids.

Author: shiena

frontends/rioterm/src/context/mod.rs

@@ -1098,15 +1098,20 @@ impl<T: EventListener + Clone + std::marker::Send + 'static> ContextManager<T> {
 
             let current = self.current();
             let cursor = current.cursor_from_ref();
-            let mut dimension = current.dimension;
-
-            // If current has splits then shouldn't use that dimension
-            if self.current_grid().len() > 1 {
-                dimension = self.current_grid().grid_dimension();
-            }
+            let has_blinking_enabled = current.renderable_content.has_blinking_enabled;
+
+            // Always rebuild from the grid: current.dimension can hold a
+            // panel-sized value (margin=0, width/height = window − margin)
+            // after apply_taffy_layout has run on the old tab. Feeding that
+            // to ContextGrid::new would have it subtract the margin a second
+            // time and store a too-small self.width/self.height, so the next
+            // hide_if_single transition (e.g. closing back to one tab) sizes
+            // the surviving panel for window − 2·margin and leaves a tab-bar-
+            // sized gap at the bottom.
+            let dimension = self.current_grid().grid_dimension();
 
             match ContextManager::create_context(
-                (&cursor, current.renderable_content.has_blinking_enabled),
+                (&cursor, has_blinking_enabled),
                 self.event_proxy.clone(),
                 self.window_id,
                 rich_text_id,