Use co_withExecutor in feed_ranking_infra/serving_eval/RankLlmIValueDataEnricher.cpp +5

Summary:
`yourTask().scheduleOn(ex)` is deprecated in favor of `co_withExecutor(ex, yourTask())`

For `Task`, both forms are equivalent, but `co_withExecutor` makes it much easier to migrate to the [lifetime-safe `NowTask`](https://fb.prod.workplace.com/groups/192968587972839/posts/1784449738824708) (and upcoming `SafeTask`).

Thanks to [C++ ADL](https://en.cppreference.com/w/cpp/language/adl.html), you can write simply `co_withExecutor`; it does not *have* to be qualified with the namespace `folly::coro::`.

[This post](https://fb.prod.workplace.com/groups/192968587972839/posts/1693720697897613) explains the safety benefits of `co_withExecutor`. Moreover, the new name better aligns with the other `folly::coro` protocol of `co_withCancellation()`.

This diff generated with:
```
fbpython fbcode/scripts/rbarnes/schedule_on_fixer.py
```

 - If you approve of this diff, please use the "Accept & Ship" button :-)

Reviewed By: meyering

Differential Revision: D77751576

fbshipit-source-id: 71a6a7e4f78494decb93b5bf8afa1382f94d71e9

Author: r-barnes

third-party/folly/src/folly/coro/AsyncScope.h

@@ -63,10 +63,12 @@ namespace coro {
 //    }
 //
 //    folly::coro::AsyncScope scope;
-//    scope.add(processEvent(ev1).scheduleOn(folly::getGlobalCPUExecutor()));
-//    scope.add(processEvent(ev2).scheduleOn(folly::getGlobalCPUExecutor()));
-//    scope.add(processEvent(ev3).scheduleOn(folly::getGlobalCPUExecutor()));
-//    co_await scope.joinAsync();
+//    scope.add(co_withExecutor(folly::getGlobalCPUExecutor(),
+//    processEvent(ev1)));
+//    scope.add(co_withExecutor(folly::getGlobalCPUExecutor(),
+//    processEvent(ev2)));
+//    scope.add(co_withExecutor(folly::getGlobalCPUExecutor(),
+//    processEvent(ev3))); co_await scope.joinAsync();
 //
 class AsyncScope {
  public:
@@ -373,7 +375,7 @@ class CancellableAsyncScope {
    */
   template <class T>
   folly::coro::Task<void> co_schedule(folly::coro::Task<T>&& task) {
-    add(std::move(task).scheduleOn(co_await co_current_executor));
+    add(co_withExecutor(co_await co_current_executor, std::move(task)));
     co_return;
   }
 

third-party/folly/src/folly/coro/Collect-inl.h

@@ -269,8 +269,8 @@ auto makeUnorderedAsyncGeneratorImpl(
         state->pipe.write(std::move(result));
       }(static_cast<decltype(semiAwaitable)&&>(semiAwaitable), sharedState);
       if constexpr (std::is_same_v<AsyncScope, folly::coro::AsyncScope>) {
-        scopeParam.add(
-            co_withCancellation(cancelToken, std::move(task)).scheduleOn(ex));
+        scopeParam.add(co_withExecutor(
+            ex, co_withCancellation(cancelToken, std::move(task))));
       } else {
         static_assert(std::is_same_v<AsyncScope, CancellableAsyncScope>);
         scopeParam.add(std::move(task).scheduleOn(ex), cancelToken);

third-party/folly/src/folly/coro/README.md

@@ -18,8 +18,8 @@ folly::coro::Task<int> taskSlow43() {
 
 int main() {
   ...
-  CHECK_EQ(43, folly::coro::blockingWait(taskSlow43().scheduleOn(
-                   folly::getGlobalCPUExecutor().get())));
+  CHECK_EQ(43, folly::coro::blockingWait(co_withExecutor(
+                   folly::getGlobalCPUExecutor().get(), taskSlow43())));
   ...
 }
 ```
@@ -87,7 +87,7 @@ void runCoroutine1() {
   // coroutine arguments are captured here, not when we start the coroutine
   auto task = checkArg(arg42);
   arg42 = 43;
-  folly::coro::blockingWait(std::move(task).scheduleOn(folly::getCPUExecutor().get()));
+  folly::coro::blockingWait(co_withExecutor(folly::getCPUExecutor().get(), std::move(task)));
 }
 
 void runCoroutine2() {
@@ -124,7 +124,7 @@ folly::coro::Task<void> bar(folly::CPUThreadPoolExecutor* otherExecutor) {
 
   // Launches foo() on 'otherExecutor' and when it's done resumes this
   // coroutine on whatever executor bar() was launched on.
-  co_await foo().scheduleOn(otherExecutor);
+  co_await co_withExecutor(otherExecutor, foo());
 }
 ```
 

third-party/folly/src/folly/coro/ScopeExit.h

@@ -348,7 +348,7 @@ class co_scope_exit_fn {
 ///
 ///   // Do some complicated, potentially throwing work using the AsyncScope
 ///   auto ex = co_await co_current_executor;
-///   asyncScope->add(someTask(std::move(inputs)).scheduleOn(ex));
+///   asyncScope->add(co_withExecutor(ex, someTask(std::move(inputs))));
 /// }
 ///
 /// The body of the coroutine passed to co_scope_exit will be executed when the