`startTls({ expectedServerHostname })` is ignored on the production edge — no SNI is sent

const socket = connect(
{ hostname: address, port: PORT },
{ secureTransport: "starttls", allowHalfOpen: false },
);
const secure = socket.startTls({ expectedServerHostname: HOSTNAME });

const writer = secure.writable.getWriter();
await writer.write(
new TextEncoder().encode(
`GET /zen HTTP/1.1\r\nHost: ${HOSTNAME}\r\n` +
`User-Agent: curl/8.7.1\r\nConnection: close\r\n\r\n`,
),
);

const reader = secure.readable.getReader();
const { value, done } = await reader.read();
return new Response(
done ? "EOF - no data received\n" : new TextDecoder().decode(value).split("\r\n")[0] + "\n",
);
},
};
```

Run it, resolving the address first (the A record rotates):

```bash
IP=$(dig +short api.github.com A | head -1)

npx wrangler dev # then: curl "localhost:8787/?ip=$IP"
npx wrangler dev --remote # then: curl "localhost:8787/?ip=$IP"
```

### Results

| | `?control=1` (connect by hostname) | `?ip=…` (connect by IP, named via `startTls`) |
| --- | --- | --- |
| `wrangler dev` (local workerd) | `HTTP/1.1 200 OK` | `HTTP/1.1 200 OK` |
| `wrangler dev --remote` (edge) | `HTTP/1.1 200 OK` | **`EOF - no data received`** |

Deterministic: 3/3 identical runs, and 0/10 in earlier runs of the same shape. The control
case shows `startTls()` itself works fine on the edge — only `expectedServerHostname` is
not applied.

### The ClientHello has no `server_name`

Capturing on a TCP endpoint under our control that the Worker reaches by IP, then calling
`startTls({ expectedServerHostname: "api.github.com" })`, the ClientHello that leaves
Cloudflare decodes as:

```
record 16 03 01 05 a7 handshake, len 1447
01 00 05 a3 ClientHello, len 1443
03 03 legacy_version TLS 1.2
<32-byte random> 20 <32-byte session id>
ciphers 00 1e 15 suites: 1301 1302 1303 c02b c02c cca9 c02f
c030 c013 c014 cca8 009c 009d 002f 0035
comp 01 00
ext 05 3c extensions, len 1340
0x0017 extended_master_secret
0xff01 renegotiation_info
0x000a supported_groups (11ec X25519MLKEM768, 6399, 001d, fe32, 0017, 0018, 0019)
0x000b ec_point_formats
0x0023 session_ticket
0x000d signature_algorithms
0x0033 key_share (1258 bytes)
0x002d psk_key_exchange_modes
0x002b supported_versions (0304, 0303)
```

There is no `0x0000` (`server_name`) extension. Because `connect()` was given an IP literal
and RFC 6066 forbids IP literals in SNI, SNI is omitted entirely rather than being filled
in from `expectedServerHostname`.

The connection-level trace of the same exchange:

```
edge -> peer len 1452 ClientHello
peer -> edge len 2848 ServerHello + Certificate + ...
edge -> peer ACK certificate received
edge -> peer len 30 ChangeCipherSpec (6) + encrypted alert (24)
edge -> peer RST
```

The server's full flight reaches Cloudflare intact; Cloudflare rejects it and resets. 30
bytes rules out the alternatives — a TLS 1.3 client `Finished` is around 60 bytes, and the
HTTP request above is ~130 bytes of plaintext.

For comparison, local workerd emits a ClientHello **with** SNI for the same code
(JA4 `t13d091000`, `d` = SNI present, 9 suites / 10 extensions) versus 15 suites /
9 extensions / no SNI on the edge. The two builds do not behave the same here.

### Not the same as #2712

#2712 reports `startTls()` failing after data has already been exchanged on the socket.
That is not what this is: a full SMTP `STARTTLS` sequence against
`smtp.gmail.com:587` — greeting, `EHLO`, `STARTTLS`, `startTls()`, `EHLO` again — succeeds
on the production edge. In that case `connect()` and the TLS peer are the same host, so no
`expectedServerHostname` is needed.

### Also ruled out

- Not flaky — 0/10 on the edge, 10/10 locally.
- Not `allowHalfOpen` — both values behave identically.
- Not stream-lock handling — acquiring and releasing the reader/writer without transferring
any data, then calling `startTls()`, works fine.
- Not the target port — 443 and 1012 fail the same way.
- Passing no options at all to `startTls()` produces the same failure, consistent with the
option never being read.

### Expected

`startTls({ expectedServerHostname })` should use that name for SNI and for certificate
verification, as local workerd does, so that a socket can be upgraded to TLS when the peer
is not identified by the `connect()` address.

### Environment