Move "async move" a few characters to the left in cx.spawn() (#26758)

This is the core change:
https://github.com/zed-industries/zed/pull/26758/files#diff-044302c0d57147af17e68a0009fee3e8dcdfb4f32c27a915e70cfa80e987f765R1052

TODO:
- [x] Use AsyncFn instead of Fn() -> Future in GPUI spawn methods
- [x] Implement it in the whole app
- [x] Implement it in the debugger 
- [x] Glance at the RPC crate, and see if those box future methods can
be switched over. Answer: It can't directly, as you can't make an
AsyncFn* into a trait object. There's ways around that, but they're all
more complex than just keeping the code as is.
- [ ] Fix platform specific code

Release Notes:

- N/A

crates/gpui/src/app/async_context.rs

@@ -8,7 +8,7 @@ use derive_more::{Deref, DerefMut};
 use futures::channel::oneshot;
 use std::{future::Future, rc::Weak};
 
-use super::Context;
+use super::{Context, WeakEntity};
 
 /// An async-friendly version of [App] with a static lifetime so it can be held across `await` points in async code.
 /// You're provided with an instance when calling [App::spawn], and you can also create one with [App::to_async].
@@ -173,12 +173,14 @@ impl AsyncApp {
 
     /// Schedule a future to be polled in the background.
     #[track_caller]
-    pub fn spawn<Fut, R>(&self, f: impl FnOnce(AsyncApp) -> Fut) -> Task<R>
+    pub fn spawn<AsyncFn, R>(&self, f: AsyncFn) -> Task<R>
     where
-        Fut: Future<Output = R> + 'static,
+        AsyncFn: AsyncFnOnce(&mut AsyncApp) -> R + 'static,
         R: 'static,
     {
-        self.foreground_executor.spawn(f(self.clone()))
+        let mut cx = self.clone();
+        self.foreground_executor
+            .spawn(async move { f(&mut cx).await })
     }
 
     /// Determine whether global state of the specified type has been assigned.
@@ -230,6 +232,19 @@ impl AsyncApp {
         let mut app = app.borrow_mut();
         Ok(app.update(|cx| cx.update_global(update)))
     }
+
+    /// Run something using this entity and cx, when the returned struct is dropped
+    pub fn on_drop<T: 'static>(
+        &self,
+        entity: &WeakEntity<T>,
+        f: impl FnOnce(&mut T, &mut Context<T>) + 'static,
+    ) -> util::Deferred<impl FnOnce()> {
+        let entity = entity.clone();
+        let mut cx = self.clone();
+        util::defer(move || {
+            entity.update(&mut cx, f).ok();
+        })
+    }
 }
 
 /// A cloneable, owned handle to the application context,
@@ -299,12 +314,14 @@ impl AsyncWindowContext {
     /// Schedule a future to be executed on the main thread. This is used for collecting
     /// the results of background tasks and updating the UI.
     #[track_caller]
-    pub fn spawn<Fut, R>(&self, f: impl FnOnce(AsyncWindowContext) -> Fut) -> Task<R>
+    pub fn spawn<AsyncFn, R>(&self, f: AsyncFn) -> Task<R>
     where
-        Fut: Future<Output = R> + 'static,
+        AsyncFn: AsyncFnOnce(&mut AsyncWindowContext) -> R + 'static,
         R: 'static,
     {
-        self.foreground_executor.spawn(f(self.clone()))
+        let mut cx = self.clone();
+        self.foreground_executor
+            .spawn(async move { f(&mut cx).await })
     }
 
     /// Present a platform dialog.