mailbox: Phase 3 — typed Pid<A> over a raw inner identity (RFC 014)

Fold the made-up Addr<A> back into the pid, where it belonged. The typed
handle IS the pid now.

- RawPid { index, generation }: today's Pid, renamed — the raw numbers, the key
  for identity-only plumbing and the heterogeneous monitor/link/pg tables.
- Pid<A = Erased>: RawPid + phantom actor type. Both an identity and a direct,
  identity-bound address; when A: Addressable a send delivers A::Msg to exactly
  this incarnation (next phase). Hand-written impls (eq/hash/fmt on the raw
  only, no A bounds); fn()->A phantom keeps it Copy+Send+Sync for any A.
- Erased: uninhabited, deliberately NOT Addressable, so a typed send to a
  Pid<Erased> won't compile — that's what send_dyn (section 4.6) will be for. It
  is the default type arg, so every plain "Pid" written today still compiles as
  Pid<Erased>; that, plus the fact that nothing destructures pid fields, is why
  an identity change touching 18 files cascaded to zero internal edits.
- Addr<A> deleted; Name<M> / the Phase-2 registry unchanged (they key on raw).

Per the call to make the consumers take typed pids: the user-facing identity
APIs — monitor, link, unlink, request_stop, spawn_under(supervisor), pg::join,
pg::leave — are now generic over A and erase at the boundary; their bodies are
byte-for-byte unchanged. Pure plumbing (unpark, set_current_pid,
register_supervisor_channel) stays erased — it only ever sees internal identity.

Phase 1's Addr tests become Pid<A> tests (identity/copy/erase/Debug, Send+Sync).
Full suite + order-checker green, warning-free across all targets.

src/link.rs

@@ -95,7 +95,8 @@ pub fn trap_exit() -> Receiver<ExitSignal> {
 /// this delivers an immediate [`DownReason::NoProc`] exit signal to the caller
 /// (a message if trapping, otherwise a cooperative stop). Linking yourself, or
 /// re-linking an existing peer, is a no-op.
-pub fn link(target: Pid) {
+pub fn link<A>(target: Pid<A>) {
+    let target = target.erase();
     let me = self_pid();
     if target == me {
         return;
@@ -163,7 +164,8 @@ pub fn link(target: Pid) {
 ///
 /// After this, neither actor's death propagates to the other. A no-op if the
 /// two were not linked.
-pub fn unlink(target: Pid) {
+pub fn unlink<A>(target: Pid<A>) {
+    let target = target.erase();
     let me = self_pid();
     if target == me {
         return;