pureboot v8: one-wire on every backend

HALF_DUPLEX deploys a shared line per backend. The hardware USART takes
the library's .half_duplex turn-around — RXD and TXD tied off-chip, each
reply byte held to transmit-complete before the line can be released
(m8 404 B, m328P 440, 1284P 460; the window poll runs through the
outlined release-line call at 18 or 22 cycles a poll, measured off the
built loops and held per chip by pureboot.window.halfduplex). The
software and autobaud links fold onto the RX pin — RX == TX spells the
same — and cost nothing: the frame's direction wrap is what the dropped
second-pin init paid, and the worst image in the space is unchanged at
the 1284s' 502 of 512, now with its one-wire twin proven equal across
the exhaustive matrix. The host gains --one-wire, the echo discard a
shared line requires: the adapter's echo is matched byte for byte and a
reply interleaving a blind write — a loader already in session
re-prompts inside the knock — is held for the reader. The device runner
models the shared line by direction (drives only while the firmware's
DDR reads input, decodes only while the firmware owns it, supplies the
host-side echo), extends the USART pin-ownership model to RXEN's hold
on RXD, and starts the pty USART from the datasheet's zeroed UCSR#B:
simavr's TXEN-set reset plus its clear-UDRE-on-TXEN-drop otherwise
wedges the first transmitter after a receiver-only program, which the
half-duplex window gate caught as a banner that never came. v7 is
tagged at its era's last commit; v8 changes nothing on the wire.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

tools/pbrig.py

@@ -87,6 +87,7 @@ class Deployment:
     port: str = ""              # serial device the loader speaks on
     baud: int = 57600           # host rate; for autobaud, the rate to drive
     autobaud: bool = False      # send the calibration pulse instead of p+b
+    one_wire: bool = False      # shared line: the host discards its own echo
     programmer: str = ""        # avrdude -c
     part: str = ""              # avrdude -p
     avrdude: str = "avrdude"
@@ -101,6 +102,7 @@ class Deployment:
             port=os.environ.get("PUREBOOT_PORT", ""),
             baud=int(os.environ.get("PUREBOOT_BAUD", "57600")),
             autobaud=os.environ.get("PUREBOOT_AUTOBAUD", "") not in ("", "0"),
+            one_wire=os.environ.get("PUREBOOT_ONE_WIRE", "") not in ("", "0"),
             programmer=os.environ.get("PUREBOOT_PROGRAMMER", ""),
             part=os.environ.get("PUREBOOT_PART", ""),
             avrdude=os.environ.get("AVRDUDE", "avrdude"),
@@ -117,6 +119,8 @@ class Deployment:
                             help="host rate (for autobaud, the rate to drive)")
         parser.add_argument("--autobaud", action="store_true", default=env.autobaud,
                             help="send the calibration pulse instead of the p+b knock")
+        parser.add_argument("--one-wire", action="store_true", default=env.one_wire,
+                            help="shared line: pass the tool its echo discard")
         parser.add_argument("--programmer", default=env.programmer, help="avrdude -c, e.g. atmelice_isp")
         parser.add_argument("--part", default=env.part, help="avrdude -p, e.g. t13 or m328p")
         parser.add_argument("--avrdude", default=env.avrdude, help="path to avrdude")
@@ -128,6 +132,7 @@ class Deployment:
     @classmethod
     def from_args(cls, args: argparse.Namespace) -> "Deployment":
         return cls(port=args.port, baud=args.baud, autobaud=args.autobaud,
+                   one_wire=args.one_wire,
                    programmer=args.programmer, part=args.part, avrdude=args.avrdude,
                    bitclock=args.bitclock, pureboot=args.pureboot, wait=args.wait)
 
@@ -267,6 +272,8 @@ class Rig:
                    "--wait", str(self.d.wait)]
         if self.d.autobaud if autobaud is None else autobaud:
             command.append("--autobaud")
+        if self.d.one_wire:
+            command.append("--one-wire")
         command += [str(a) for a in args]
         try:
             result = subprocess.run(command, capture_output=True, text=True, timeout=timeout)