Make the UI test suite runnable again, and shardable across remote Macs

[yusuftor]

The suite had not run in CI since it was written: the workflow only pushed a
tag for Xcode Cloud, and on a current Mac the project did not compile at all.
This gets it building, running and splitting into shards, so it can go wide on
Limrun from Linux runners.

Draft, because the stored images still have to be taken again — see What is
left below.

What was broken

It did not build. Configuration_ObjC.h names four SuperwallKit types
while importing only Foundation. It used to compile because another header
pulled the module in first; Xcode 27 builds modules explicitly, so include
order no longer leaks those types in and all four schemes failed. Confirmed
on an untouched main.

Every test hung for five minutes and then failed. Three faults in a row:

• deleteApp asked for each button through the view holding it
  (collectionViews.buttons["Remove App"]). The wording of those steps is
  unchanged, but the nesting is not, so the query matched nothing and the app
  was never removed.
• With the app already installed, the StoreKit session was set up too late and
  the app started with no products — the exact case the helper's own error
  message warns about. The helper retried by restarting the same
  SKProductsRequest, which answers once and is then spent, so no callback
  ever came. It then gave up with assertionFailure, which traps in a debug
  build, so the app died rather than reporting.
• launchApp discarded the result of waiting for the foreground, and the
  runner had no timeout of its own, so it waited on an app that was no longer
  running.

It tested the wrong code. The project tracks the SDK's develop, so a run
picked up whatever that branch held rather than the commit that asked for it.
The dispatch already carried a commit; nothing used it.

What this changes

• One import, and the project builds again.
• deleteApp asks Springboard for each button directly and waits for it, then
  waits for the icon to go.
• A fresh products request per attempt; a failure reports instead of killing
  the app.
• The launch is checked, and the runner has a timeout for an app that stops
  answering. The app keeps its own shorter one and still reports first.
• scripts/pin-sdk.py --commit <sha> pins the SDK to the commit under test.
• scripts/run-tests.py plan|run splits the suite into shards, on this Mac or
  on a remote one with --runner lim. Classes are dealt round-robin, since
  test numbers group by feature and contiguous slices hand one shard all the
  slow paywall tests.
• The workflow plans the shards and runs ten at a time — Limrun caps instances
  per org and a shard holds two, a sandbox and a simulator. The Xcode Cloud tag
  job stays until this path has proven itself.
• Snapshots compare on how close each pixel is, not only how many match
  exactly. Text rendering moves a lot of pixels by a little between machines
  and iOS minor versions, and Limrun does not promise a fixed minor version.

Verified

• Both a Swift and an Objective-C scheme build.
• Test 0 passes end to end: app removed, StoreKit session set up, app
  installed and launched, SDK configured, paywall rendered with the attribute
  the test sets, image matched on a second run. 70 seconds, down from 542.
• Shards are complete and disjoint at 1, 3, 10, 179 and 200 shards.
• pin-sdk.py round-trips the project file byte for byte.

Nothing has run on Limrun yet — that needs LIM_API_KEY.

What is left

• Re-record the images. They were taken on an iPhone 14 Pro at 393x818
  points; the suite now targets 402x840, so every image assertion fails on
  size alone. scripts/run-tests.py run --record does it, but it is roughly
  700 cases and many hours, and recording makes whatever renders the new
  truth, so it wants a person watching. Test 0 is recorded here as proof the
  loop closes.
• Test 126 crashes the app. A real fault, not a snapshot difference.
• In a sample of eight tests the failures were four snapshot mismatches and
  that one crash, so the expected mode dominates.
• A crashed app costs the runner its full timeout. Noticing the app has gone
  would cut that.

🤖 Generated with Claude Code