Avoid fully awaiting futures in async event loops

[jedel1043]

This fixes a small bug where a single future that enqueues a promise job could block executing the promise job queue. For example:

fn delay(
    _this: &JsValue,
    args: &[JsValue],
    context: &RefCell<&mut Context>,
) -> impl Future<Output = JsResult<JsValue>> {
    let millis = args.get_or_undefined(0).to_u32(&mut context.borrow_mut());

    context
        .borrow_mut()
        .enqueue_job(Job::PromiseJob(PromiseJob::new(|_| {
            println!("ran a job!");
            Ok(JsValue::undefined())
        })));

    async move {
        let millis = millis?;
        let now = Instant::now();
        smol::Timer::after(Duration::from_millis(u64::from(millis))).await;
        let elapsed = now.elapsed().as_secs_f64();
        Ok(elapsed.into())
    }
}

In the previous implementation of the event loops, the queued job would only execute if the returned async method finished executing. With the new implementation, every loop only polls the pending futures once before draining the promise job queue again.

[github-actions]

Test262 conformance changes

Test result	main count	PR count	difference
Total	50,595	50,595	0
Passed	47,238	47,238	0
Ignored	1,964	1,964	0
Failed	1,393	1,393	0
Panics	0	0	0
Conformance	93.36%	93.36%	0.00%

[HalidOdat]

Looks good to me! :)