Address review: tighten arc winding tolerance and fix negative spans

- Replace the 1e-9 magic tolerance with 1e-12 turns, justified by the
  observed error from the polar transform pipeline (machine-epsilon level,
  under 1e-15 turns), via np.rint(n_turns).
- Snap on any non-zero whole number of turns (abs winding), restoring the
  legacy full-circle behaviour for exact negative multiples such as
  Path.arc(0, -360); the previous rework collapsed those to an empty arc.
- Add regression tests for negative full circles and a tolerance-tightness
  guard (a span just past a full turn must not snap).

Author: SharadhNaidu

lib/matplotlib/path.py

@@ -995,13 +995,16 @@ def arc(cls, theta1, theta2, n=None, is_wedge=False):
 
         eta1 = theta1
         n_turns = (theta2 - theta1) / 360
-        # If the requested span is within floating-point tolerance of a whole
-        # number of turns, draw a complete circle.  Otherwise unwrap *theta2*
-        # to the shortest arc within 360 degrees.  Snapping near-integer
-        # windings here avoids the edge case where a delta of 360*n plus a
-        # tiny rounding error would otherwise collapse to a near-empty arc.
-        if (theta2 != theta1 and round(n_turns) >= 1
-                and abs(n_turns - round(n_turns)) < 1e-9):
+        nearest_turn = np.rint(n_turns)
+        # If the span is within floating-point tolerance of a non-zero whole
+        # number of turns, draw a complete circle; otherwise unwrap *theta2*
+        # to the shortest arc within 360 degrees.  Without the snap, a span of
+        # 360*n plus a tiny rounding error is reduced modulo 360 to a
+        # near-empty arc (the polar gridline/spine collapse).  The error from
+        # the polar transform pipeline is at the machine-epsilon level (under
+        # 1e-15 turns in practice), so this tolerance reliably snaps genuine
+        # full turns while leaving any intentionally non-integer span alone.
+        if nearest_turn != 0 and abs(n_turns - nearest_turn) <= 1e-12:
             eta2 = theta1 + 360
         else:
             eta2 = theta2 - 360 * np.floor(n_turns)

lib/matplotlib/tests/test_path.py

@@ -511,25 +511,45 @@ def test_full_arc(offset):
     np.testing.assert_allclose(maxs, 1)
 
 
-@pytest.mark.parametrize('theta2', [360 + 1e-9, 720, 720 + 1e-9, 360 * 5])
+@pytest.mark.parametrize('theta2', [
+    360, 720, 360 * 5,                       # exact whole turns
+    np.nextafter(360, 1e6),                  # +1 ulp: realistic float noise
+    np.nextafter(360, 0),                    # -1 ulp
+    np.nextafter(720, 1e6),
+])
 def test_arc_full_circle_snap(theta2):
-    # A span that is within floating-point tolerance of a whole number of
-    # turns must draw a complete circle, not collapse to a near-empty arc.
-    # This is the floating-point edge case behind gh-20388 and gh-26972.
+    # A span within floating-point tolerance of a whole number of turns must
+    # draw a complete circle, not collapse to a near-empty arc.  This is the
+    # floating-point edge case behind gh-20388 and gh-26972.
     full = Path.arc(0, 360)
     snapped = Path.arc(0, theta2)
     assert len(snapped.vertices) == len(full.vertices)
     np.testing.assert_allclose(np.min(snapped.vertices, axis=0), -1, atol=1e-12)
     np.testing.assert_allclose(np.max(snapped.vertices, axis=0), 1, atol=1e-12)
 
 
+@pytest.mark.parametrize('theta1, theta2', [(0, -360), (0, -720), (360, 0),
+                                            (10, -350)])
+def test_arc_negative_full_circle(theta1, theta2):
+    # An exact negative multiple of 360 must still draw a complete circle,
+    # matching the legacy behaviour (regression guard for the unwrap rework).
+    # The result is the same complete circle as the equivalent positive turn
+    # starting from *theta1* (so the assertion holds for non-cardinal starts).
+    np.testing.assert_allclose(Path.arc(theta1, theta2).vertices,
+                               Path.arc(theta1, theta1 + 360).vertices)
+
+
 def test_arc_unwrap_partial_turn():
     # A span comfortably more than a whole number of turns (not near-integer)
     # is still unwrapped to the equivalent shortest arc within 360 degrees.
     np.testing.assert_allclose(Path.arc(0, 410).vertices,
                                Path.arc(0, 50).vertices)
     np.testing.assert_allclose(Path.arc(0, 540).vertices,
                                Path.arc(0, 180).vertices)
+    # A span a clear fraction of a degree past a full turn is the caller's
+    # explicit request and must NOT be snapped to a circle (tolerance guard).
+    np.testing.assert_allclose(Path.arc(0, 360.001).vertices,
+                               Path.arc(0, 0.001).vertices)
 
 
 def test_disjoint_zero_length_segment():