feat(channel): selective receive — recv_match + try_recv_match (roadmap #4)

recv_match(pred) scans the queue front-to-back, removes and returns the
first match (rest preserved in arrival order), and parks/re-scans on every
send when nothing matches — a selective receiver may park on a non-empty
queue. Returns Err only once the channel is closed with no queued match.
try_recv_match is the non-blocking variant, mirroring try_recv.

Sender::drop now wakes the parked receiver on the last-sender drop
regardless of queue emptiness, so a selective receiver parked on a
non-empty no-match queue observes closure instead of sleeping forever.
No-op for plain recv (which only ever parks on an empty queue).

src/channel.rs

@@ -69,7 +69,13 @@ impl<T> Drop for Sender<T> {
         let unpark = {
             let mut g = self.inner.lock().unwrap();
             g.senders -= 1;
-            if g.senders == 0 && g.queue.is_empty() {
+            // Wake the parked receiver on the last sender drop regardless of
+            // whether the queue is empty. A plain `recv` only ever parks on an
+            // empty queue (so this is unchanged for it), but a selective
+            // `recv_match` may be parked on a *non-empty* queue holding only
+            // non-matching messages — it must wake to observe closure and
+            // return Err rather than sleep forever.
+            if g.senders == 0 {
                 g.parked_receiver.take()
             } else {
                 None
@@ -134,6 +140,64 @@ impl<T> Receiver<T> {
         }
     }
 
+    /// Selective receive: remove and return the first queued message for which
+    /// `pred` holds, leaving the rest in arrival order. If no queued message
+    /// matches, parks and re-scans on every send (a selective receiver may park
+    /// on a *non-empty* queue). Returns `Err(RecvError)` only once the channel
+    /// is closed and no queued message matches.
+    ///
+    /// `pred` is run while the channel lock is held: keep it cheap and pure,
+    /// and do not call back into this channel from inside it. It is modelled as
+    /// `Fn` (not `FnMut`) deliberately — it is re-run from scratch on every
+    /// scan, so a stateful predicate would observe surprising re-counting.
+    pub fn recv_match<F>(&self, pred: F) -> Result<T, RecvError>
+    where
+        F: Fn(&T) -> bool,
+    {
+        loop {
+            {
+                let mut g = self.inner.lock().unwrap();
+                if let Some(i) = g.queue.iter().position(|v| pred(v)) {
+                    // position() found it, so remove() returns Some.
+                    return Ok(g.queue.remove(i).unwrap());
+                }
+                if g.senders == 0 {
+                    // Closed and nothing queued can ever match.
+                    return Err(RecvError);
+                }
+                let me = crate::actor::current_pid()
+                    .expect("recv_match() called outside an actor");
+                debug_assert!(
+                    g.parked_receiver.is_none(),
+                    "channel has more than one receiver"
+                );
+                g.parked_receiver = Some(me);
+                crate::te!(crate::trace::Event::RecvPark(me));
+            }
+            // Release the lock before parking — the unparker will need it.
+            crate::scheduler::park_current();
+            crate::te!(crate::trace::Event::RecvWake(crate::actor::current_pid().unwrap()));
+        }
+    }
+
+    /// Non-blocking selective receive. `Ok(Some(v))` if a queued message
+    /// matched `pred` (removed, rest left in order), `Ok(None)` if the channel
+    /// is open but nothing matched, `Err(RecvError)` if closed and nothing
+    /// matched. Same predicate contract as [`recv_match`](Self::recv_match).
+    pub fn try_recv_match<F>(&self, pred: F) -> Result<Option<T>, RecvError>
+    where
+        F: Fn(&T) -> bool,
+    {
+        let mut g = self.inner.lock().unwrap();
+        if let Some(i) = g.queue.iter().position(|v| pred(v)) {
+            return Ok(Some(g.queue.remove(i).unwrap()));
+        }
+        if g.senders == 0 {
+            return Err(RecvError);
+        }
+        Ok(None)
+    }
+
     /// Non-blocking. `Ok(Some(v))` if a message was available, `Ok(None)` if
     /// the channel is empty but open, `Err(RecvError)` if closed and drained.
     pub fn try_recv(&self) -> Result<Option<T>, RecvError> {