Fix InsideStrokedRectangle to inset stroke under any transform

The previous implementation shrank the rectangle's bounds by lw/2 in data
units, which only happens to be correct in the DrawingArea's
points-as-units transform; under transData, transAxes, or any other
transform it inset by the wrong amount. It also failed to restore the
bounds after drawing, so each redraw shrank the patch further.

Replace it with a clip-to-self approach: stroke at 2·lw centred on the
path, then clip to the patch's own boundary so the outer half is erased.
The visible stroke ends up fully inside the rectangle with its outer edge
on the original boundary, in any transform, idempotently across redraws.
Snapshot and restore _dash_pattern around the linewidth change so dashed
strokes render at the requested length rather than 2× longer.

Author: has2k1

plotnine/_mpl/patches.py

@@ -111,16 +111,41 @@ def draw(self, renderer):
 
 class InsideStrokedRectangle(Rectangle):
     """
-    A rectangle whose stroked is fully contained within it
+    A rectangle whose stroke is fully contained within it
     """
 
     @artist.allow_rasterization
     def draw(self, renderer):
         """
-        Draw with the bounds of the rectangle adjusted to contain the stroke
+        Draw stroking at 2·lw and clipping to the rectangle's own boundary
+
+        The outer half of the stroke is removed by the clip, leaving exactly
+        `lw` of stroke fully inside the rectangle, with the visible outer edge
+        of the stroke on the original boundary. This is transform-agnostic
+        (works under data, axes, identity, and DrawingArea transforms) and
+        idempotent across redraws.
         """
-        x, y = self.xy
-        w, h = self.get_width(), self.get_height()
         lw = self.get_linewidth()
-        self.set_bounds((x + lw / 2), (y + lw / 2), (w - lw), (h - lw))
-        super().draw(renderer)
+        if lw <= 0:
+            return super().draw(renderer)
+
+        saved_clip_path = self.get_clip_path()
+        saved_clip_on = self.get_clip_on()
+
+        # Dash lengths track the linewidth: matplotlib stores the dash
+        # pattern as multipliers and scales them whenever set_linewidth is
+        # called. Doubling lw below would therefore stretch the dashes 2x.
+        # Snapshot the pattern at the user's lw now and write it back after
+        # the doubling so the dashes render at their requested length.
+        original_dash_pattern = self._dash_pattern
+        try:
+            self.set_linewidth(2 * lw)
+            self._dash_pattern = original_dash_pattern
+            self.set_clip_path(self.get_path(), self.get_transform())
+            self.set_clip_on(True)
+            self.set_snap(False)
+            super().draw(renderer)
+        finally:
+            self.set_linewidth(lw)
+            self.set_clip_path(saved_clip_path)
+            self.set_clip_on(saved_clip_on)