Post task updates to the loop instead of waking it

`WakeTaskQueue` becomes `TaskQueue`, which carries the update itself.
Delivery and waking are then one act: the winit host sends it through the
`EventLoopProxy` as a `DefaultEvent::Update`, so there is no channel
beside the loop and nothing has to claim a redraw is needed in order to be
looked at. `Window::request_redraw` is gone from this path; `event`
applies the update and then asks the tree whether anything became dirty,
which is the same question `window_event` already ended with -- now
`schedule_redraw`, called from both.

The loop's message type is `DefaultEvent<State>`, so `Proxy` becomes a
wrapper that takes the application's own `Event` and requires it to be
`Send`, since it now crosses to the task thread by that route.

The harness supplies a channel-backed queue, which is what lets a test
hold updates until it asks for them.

Tests split by subject -- layout, pointer, scroll, tasks -- with the
region helper in `tests/common`.

src/harness.rs

@@ -4,13 +4,22 @@
 //! It does not draw. A claim about pixels still needs a real surface.
 
 use crate::prelude::*;
-use std::{sync::Arc, time::Duration};
+use std::{
+    sync::{
+        Arc,
+        mpsc::{Receiver, SyncSender, sync_channel},
+    },
+    time::Duration,
+};
 
-/// The harness drains the update queue itself, so there is no loop to wake.
-struct NoWake;
+/// There is no loop here to post to, so updates queue until the test asks
+/// for them.
+struct Queue(SyncSender<Box<dyn TaskUpdate<DefaultRsc<HarnessState>>>>);
 
-impl WakeTaskQueue for NoWake {
-    fn wake(&self) {}
+impl TaskQueue<DefaultRsc<HarnessState>> for Queue {
+    fn send(&self, update: Box<dyn TaskUpdate<DefaultRsc<HarnessState>>>) {
+        let _ = self.0.send(update);
+    }
 }
 
 #[derive(Default)]
@@ -28,14 +37,18 @@ pub struct Harness {
     pub rsc: DefaultRsc<HarnessState>,
     pub render: UiRenderState,
     pub state: HarnessState,
-    updates: TaskMsgReceiver<DefaultRsc<HarnessState>>,
+    updates: Receiver<Box<dyn TaskUpdate<DefaultRsc<HarnessState>>>>,
     cursor: CursorState,
 }
 
 impl Harness {
     /// `size` is the output in physical pixels.
     pub fn new(size: impl Into<Vec2>) -> Self {
-        let (rsc, updates) = DefaultRsc::init(Arc::new(NoWake));
+        // A `TaskQueue` must be `Sync`, which `mpsc::Sender` is not; the
+        // bound that comes with `SyncSender` is far past anything a test
+        // leaves unread.
+        let (send, updates) = sync_channel(1024);
+        let rsc = DefaultRsc::init(Arc::new(Queue(send)));
         let mut render = UiRenderState::new();
         render.resize(size);
         Self {