feat(ios-device): pinch, rotate and multi-finger paths on a physical iPhone - #1664

…physical iPhone (#1715)

Makes a `gesture-custom` path train on a physical iPhone hold the finger
through each event's `delayMs`, then move it, as a simulator does.

## Why

`delayMs` is the wait before an event, with the finger where it was. On
a simulator the finger rests, then moves to the event's point. On a
physical iPhone, path trains go through the runner's `touchPaths`, and
XCTest glides a finger between consecutive waypoints, so the finger
started moving as soon as the delay began.

A press, a 1 s wait, and a move:

```json
[
  { "type": "Down", "x": 0.5, "y": 0.47 },
  { "type": "Move", "x": 0.5, "y": 0.3, "delayMs": 1000 },
  { "type": "Up", "x": 0.5, "y": 0.3 }
]
```

On a link in Safari this opens the link menu on a simulator. On an
iPhone it scrolled the page, because the finger never held still. Before
#1664 the phone refused this train; since then it played a different
gesture without saying so, and an e2e step recorded on a simulator
replayed as a scroll on a phone.

## What changes

- `trainPaths` adds a waypoint at the finger's last point 1 ms before
each event that moves it. The finger rests through the delay, then
reaches the event's point. Both fingers get the same treatment.
- No rest is added when the finger stays put, or when the delay is 1 ms
or less.
- A train with few, far-apart events now moves in steps on an iPhone, as
it does on a simulator. `interpolate` still adds intermediate frames for
smooth motion.
- Unchanged: pinch and rotate (their paths come from `pinchPaths` and
`rotatePaths`), and the plain Down/Up and long-press pickup trains,
which still go through XCUICoordinate.

## Docs and tests

- No docs change: this is the documented `delayMs` behaviour ("Delay
before this event"), and the `gesture-custom` description already points
to `interpolate` for smooth motion.
- `ios-device-touch-paths.test.ts`: the rest before a move, and no rest
for a finger that stays put or a 1 ms delay. Updated waypoints for the
existing trains.
- `gesture-custom.test.ts`: updated waypoints for the two-finger,
waypoint and interpolate trains.

Conflicts were resolved by keeping the trimmed text from this branch and
adding the new facts from main in shorter form:

- Physical iPhone pinch/rotate (#1664): gesture-pinch, gesture-rotate and
  gesture-custom state the portrait limit and the reactivated flag;
  run-sequence lists pinch/rotate for physical iOS; the iOS-device, e2e and
  QA skills drop the "no two-finger gestures" lines.
- Remote simulator recording (#971): the screen-recording tools accept
  remote simulators and say that stop downloads the mp4; the skill lists
  remote simulators as recordable and notes that landscape plays sideways.
- rotate refuses Android TV (#1354): rotate becomes createRotateTool and
  says it fails on a TV target.

…at never go idle (#1722)

On a physical iPhone, a gesture on a screen that never goes idle
(Bluesky's profile: expo-blur keeps a paused `UIViewPropertyAnimator`)
took 60-120 s and then failed with `RUNNER_BUSY`. Two things caused it:

- **Slow:** XCTest waits up to 60 s before and after every event for the
app to go idle.
- **Repeated:** the MCP adapter aborts a call after 30 s and sends it
again. The tool-server keeps running each aborted call, so one
`gesture-tap` landed 2-5 times.

**Fix:**
- The runner skips XCTest's idle waits and instead waits at most 2 s for
the app to settle before each event.
- `gesture-tap`, `gesture-swipe`, `gesture-custom`, `gesture-pinch`,
`gesture-rotate` and `button` are `longRunning`, as `keyboard` already
is.

| Stalled screen, one MCP `gesture-tap` | main | this PR |
|---|---|---|
| time | 135 s, then `RUNNER_BUSY` | ~5 s, ok |
| physical taps | 2 | 1 |
| text entry (focus / type) | 75 s / 55 s, both timed out | 2.3 s / 3.4
s, text landed |

> [!NOTE]
> **This uses private XCTest API.** There's no screenshotting or
sleep-polling. `ArgentRunnerSession+Quiescence.swift`:
> 1. Calls the same check XCTest runs on its own (`applicationImpl` →
`currentProcess` → `_initiateQuiescenceChecksIncludingAnimationsIdle:`
and `_makeQuiescenceExpectation`), but waits on it for at most 2 s
instead of 60 s.
> 2. Sends the event inside `-[XCUIApplication
_performWithInteractionOptions:block:]` with options `0b11` (skip the
pre-event and post-event waits). This is the same SPI agent-device uses.
>
> Selectors are resolved with `NSSelectorFromString` and called through
`unsafeBitCast` IMPs, and each one is checked with `responds(to:)`
first. If an Xcode drops one, the gesture falls back to XCTest's normal
60 s waits rather than crashing.
>
> **Cost:** on a screen that never goes idle, every gesture now waits
the full 2 s. On main it waited 60-120 s. Skipping the wait entirely
(0.4 s) lost taps sent right after a navigation (0/5 landed).

Docs: no docs-site change. `longRunning` is internal, and the runner's
PROTOCOL.md/README are updated.

<details>
<summary>Repro and verification</summary>

No physical iPhone was used. The real runner ran on an iOS 18.5
simulator, with stub `xcrun`/`xcodebuild` and a fake usbmuxd making the
tool-server treat it as a phone. The tool-server, MCP adapter and runner
were the real code. The fixture app stalls XCTest with either a paused
`UIViewPropertyAnimator` on a visual-effect view or a repeating
`UIView.animate`.

Direct to the runner:

| Case | main | this PR |
|---|---|---|
| Stalled screen, 3 taps | 60.5 s ok; 75.1 s `COMMAND_TIMED_OUT`; then
`RUNNER_BUSY` | 0.41 s, then 2.32-2.35 s each; 6/6 landed (both stall
types) |
| Stalled screen, focus / type / delete / return | 75 / 55 / 30 / 30 s,
all timed out | 2.34 / 3.36 / 3.32 / 2.42 s, all ok |
| Stalled screen, doubleTap / longPress / drag | - | 2.48 / 3.10 / 2.80
s, all landed |
| Normal screen: open modal, wait 100 ms, close (5 runs) | 5/5, close
took 1.0-1.1 s | 5/5, close took 0.75-0.82 s |
| `touchPaths` pinch (from #1664), stalled vs normal | - | ~0.74 s on
both, 3/3 registered (synthesized directly, never waited for idle) |

Through MCP, first tap of a session with the runner build padded to 45
s: main gave 2 tool calls and 2 taps (the app saw a double tap); this PR
gives 1 call and 1 tap.

Local checks: `npm run build`, `typecheck:tests`, prettier and eslint
pass. vitest passed 826 tests across the gesture, button, keyboard,
http, ios-device, ios-physical and run-sequence suites. The runner
builds for a real device (`build-for-testing generic/platform=iOS`).
`ios-device-gestures-long-running.test.ts` fails when any single
`longRunning` flag is removed.

Not fixed here:
- A first runner build longer than 300 s is still replayed (#1632).
- Bringing a backgrounded app to the foreground still uses XCTest's
normal waits, capped at about 15 s.
- #1528's `element.tap()` would need the same `skippingQuiescence`
wrapper.
</details>