LibCore: Fix compilation of infallible Promise::when_resolved handlers

This overload is currently unused. When used, it doesn't compile due to
mismatched return types in the handler provided to the function and the
type of `on_resolution`.

Tests/LibCore/TestLibCorePromise.cpp

@@ -61,6 +61,26 @@ TEST_CASE(promise_chain_handlers)
     EXPECT(!rejected);
 }
 
+TEST_CASE(infallible_promise_chain_handlers)
+{
+    Core::EventLoop loop;
+
+    bool resolved = false;
+    bool rejected = false;
+
+    NonnullRefPtr<Core::Promise<int>> promise = MUST(Core::Promise<int>::try_create())
+                                                    ->when_resolved([&](int&) { resolved = true; })
+                                                    .when_rejected([&](AK::Error const&) { rejected = true; });
+
+    loop.deferred_invoke([=] {
+        promise->resolve(42);
+    });
+
+    (void)promise->await();
+    EXPECT(resolved);
+    EXPECT(!rejected);
+}
+
 TEST_CASE(promise_map)
 {
     Core::EventLoop loop;

Userland/Libraries/LibCore/Promise.h

@@ -82,13 +82,10 @@ public:
     template<CallableAs<void, Result&> F>
     Promise& when_resolved(F handler)
     {
-        on_resolution = [handler = move(handler)](Result& result) { return handler(result); };
-        if (is_resolved()) {
-            auto handler_result = on_resolution(m_result_or_rejection->value());
-            possibly_handle_rejection(handler_result);
-        }
-
-        return *this;
+        return when_resolved([handler = move(handler)](Result& result) -> ErrorOr<void> {
+            handler(result);
+            return {};
+        });
     }
 
     template<CallableAs<ErrorOr<void>, Result&> F>