Wire ExternalAxis to send LINE blocks (full S-curve mirror to ESP)

Replaces the legacy 'fixed-rate STEPS' path used in Planner.__encode
with a new ExternalAxis.enqueue_line() that hands the ESP the full
7-segment S-curve parameters of every gplan line block (max_accel,
max_jerk, entry_vel, exit_vel, times[7]).

The ESP's new LINE command (auxcnc commit 8acc6f7) integrates the
same SCurve math the AVR uses, so the W axis now physically moves
in lockstep with whatever the planner thinks A is doing. Result:
DRO stays in sync with the actual stepper, no more multi-second lag
between commanded and observed A position.

enqueue_target_mm is kept as a no-frills STEPS path for jog/move UI
endpoints that don't have planner timing context.

AuxAxis._do_line builds the LINE command with mm/min/min^2/min^3
units (matching gplan's internal unit system) and waits for
[line] done|aborted from the ESP. Limit aborts still flag _homed=False.

src/py/bbctrl/ExternalAxis.py

@@ -339,25 +339,13 @@ class ExternalAxis(object):
             self._busy.clear()
 
     def enqueue_target_mm(self, ext_mm):
-        """Non-blocking variant: post a target to the worker queue.
-        Used by Planner.__encode in the hot path.
-
-        We deliberately do NOT mirror the new target into state.<axis>p
-        here. The AVR also receives the line block (we don't strip
-        the external axis from the AVR target) and its trapezoid
-        progressively updates ex.position[A] -> reports back as ap.
-        If we set state.ap here ahead of the AVR, the DRO would jump
-        to the target and then snap back to intermediate values as
-        AVR reports stream in. Instead we let the AVR drive state.ap.
-        We still mirror the new abs into our internal _pos_mm so
-        the next line block computes the correct delta.
-
-        The Planner.__encode hook calls this so the AVR comm thread
-        is never blocked by serial RPCs to the ESP.
+        """Legacy non-blocking variant: post a fixed-rate STEPS move
+        to the worker queue. No longer used by Planner.__encode (which
+        uses enqueue_line for full S-curve mirroring), but kept for
+        UI jog endpoints that don't have planner timing data.
 
         Soft limits are enforced here (defense in depth on top of
-        gplan). Raising stops the planner via Planner.next's
-        exception handler."""
+        gplan)."""
         if not self.enabled:
             raise ExternalAxisError(
                 'External axis %r not available' % self.axis_letter)
@@ -370,6 +358,48 @@ class ExternalAxis(object):
             return
         self._work_q.put(('move', steps))
 
+    def enqueue_line(self, ext_mm, max_accel_mm_min2, max_jerk_mm_min3,
+                     entry_vel_mm_min, exit_vel_mm_min, times_ms):
+        """Post a full S-curve LINE block to the ESP worker. Mirrors
+        gplan's planned trajectory exactly (same 7-segment math, same
+        unit system) so the ESP's move duration matches what the AVR
+        would have produced for an A motor.
+
+        Called by Planner.__encode for every line block that touches
+        the external axis.
+
+        Parameters:
+          ext_mm:           absolute target in mm (gplan target['a'])
+          max_accel_mm_min2:from block['max-accel']
+          max_jerk_mm_min3: from block['max-jerk']
+          entry_vel_mm_min: from block['entry-vel'] (typically 0 for
+                            the first block, exit_vel of the prior
+                            block otherwise)
+          exit_vel_mm_min:  from block['exit-vel']
+          times_ms:         7-tuple of section durations in ms
+                            (block['times'] - the same units gplan uses)
+        """
+        if not self.enabled:
+            raise ExternalAxisError(
+                'External axis %r not available' % self.axis_letter)
+        self._check_soft_limit(ext_mm)
+        steps, abs_mm = self._compute_move(ext_mm)
+        delta_mm = abs(abs_mm - (self._pos_mm if self._pos_mm is not None
+                                 else 0.0))
+        # Update internal mirror; AVR drives state.<axis>p.
+        self._pos_mm = abs_mm
+        if steps == 0 or delta_mm <= 0:
+            return
+        # ms -> minutes (the unit gplan/AVR/ESP use internally for
+        # SCurve math).
+        times_min = tuple((t / 60000.0) if t else 0.0 for t in times_ms)
+        self._work_q.put(('line', steps, delta_mm,
+                          float(max_accel_mm_min2),
+                          float(max_jerk_mm_min3),
+                          float(entry_vel_mm_min),
+                          float(exit_vel_mm_min),
+                          times_min))
+
     def _compute_move(self, ext_mm):
         """Return (signed_steps, absolute_mm) for a target in mm.
         Caches first-time position from the ESP."""
@@ -397,6 +427,15 @@ class ExternalAxis(object):
                 if kind == 'move':
                     steps = op[1]
                     self.aux._do_steps(steps, ignore_limits=True)
+                elif kind == 'line':
+                    (_, steps, length_mm,
+                     max_accel, max_jerk,
+                     entry_vel, exit_vel,
+                     times_min) = op
+                    self.aux._do_line(
+                        steps, length_mm, max_accel, max_jerk,
+                        entry_vel, exit_vel, times_min,
+                        ignore_limits=True)
                 elif kind == 'home':
                     self.aux.home()
                     # _pos_mm and DRO updated by the caller's enqueue.