fix: carry EIP-1193 error codes through to the page (closes #274)

src/content/inpage.js rebuilt every failure as `new Error(error.message)`,
so the `code` the background produced and the content script relayed intact
was dropped in the last hop. A dApp checking `err.code === 4001` — the
standard way to tell "the user said no" from "something broke" — saw
`undefined`, which makes a wallet the user deliberately declined
indistinguishable from a wallet that failed.

The provider now rejects with an EIP-1193 `ProviderRpcError` carrying the
`code` and, where the boundary sent one, `data`. A class rather than
properties attached to an `Error`: the object crosses no boundary after
construction — it is built in the page's own realm and handed straight to
the caller's catch — so the prototype survives and `name` is a stable thing
for a dApp to see.

Whatever code arrived is passed through verbatim rather than matched
against a list. The background emits 4001, 4100 and 4902 on the RPC path
today; a code added later must reach the page without editing the provider.
An error the background sent with no code stays a plain `Error` with no
`code` property at all — a `ProviderRpcError` whose `code` is `undefined`
would advertise a conformance it does not have. `message` is unchanged in
every case, and nothing the background produces changes.

Every entry point the provider exposes funnels through the one response
listener, so `request`, `enable`, `send` and `sendAsync` are all covered;
tests/inpageErrors.test.js loads the real inpage.js against a stub window
and asserts each of them, both codes and the untouched messages.

The e2e probe added for #183, which printed the missing code on all four
rejected flows rather than asserting it, now requires code 4001 on the
page's Error as well as on the wire. Without the provider change it fails
on all four with "reached the page as an error with no code property at
all".

tests/e2e/run.js

@@ -1591,15 +1591,14 @@ async function lastResponseError(page) {
 }
 
 // A rejected prompt, asserted at both ends: the page's promise rejected
-// rather than hanging or resolving, and the response that crossed the
-// boundary carried EIP-1193 code 4001.
+// rather than hanging or resolving, and EIP-1193 code 4001 is present both
+// on the wire and on the Error the calling page catches.
 //
-// The code is asserted on the wire because that is the only place it
-// survives. src/content/inpage.js rebuilds the rejection as `new
-// Error(error.message)`, so the Error the calling page catches carries the
-// message and no code. That is reported rather than asserted either way —
-// locking in the current behaviour would make the gap permanent, and
-// asserting the code on the Error would fail today.
+// Both ends matter because they used to disagree. The code crossed the
+// boundary correctly and src/content/inpage.js then threw it away, rebuilding
+// every rejection as `new Error(error.message)` — so a dApp branching on
+// `err.code === 4001` saw undefined and could not tell a refusal from a
+// failure (#274). Asserting only the wire would leave that gap invisible.
 async function assertUserRejection(page, key, label) {
     const outcome = await settleRequest(page, key);
     assert(
@@ -1621,15 +1620,32 @@ async function assertUserRejection(page, key, label) {
             " did not carry EIP-1193 code 4001 across the boundary: " +
             JSON.stringify(error),
     );
+    assert(
+        outcome.hasCode,
+        label +
+            " reached the page as an error with no code property at all, so a " +
+            "dApp cannot tell the user's refusal from a failure: " +
+            JSON.stringify(outcome),
+    );
+    assert(
+        outcome.code === 4001,
+        label +
+            " reached the page with code " +
+            JSON.stringify(outcome.code) +
+            " rather than EIP-1193 4001",
+    );
+    assert(
+        outcome.name === "ProviderRpcError",
+        label +
+            " reached the page as " +
+            JSON.stringify(outcome.name) +
+            " rather than an EIP-1193 ProviderRpcError",
+    );
     console.log(
         "# " +
             label +
-            ": boundary code=" +
-            error.code +
-            " page Error.code=" +
-            JSON.stringify(outcome.code) +
-            " page Error carries a code=" +
-            outcome.hasCode,
+            ": code 4001 on the wire and on the page's " +
+            outcome.name,
     );
     return outcome;
 }