Create closure type; allow async event handlers in props; allow short hand event handlers

[ealmloff]

Fixing EventHandler Discrepancies

This PR fixes three rough spots with EventHandler:

1. You can't return values from EventHandler. This PR introduces a new Callback type that lets you return values. closes Tweak on* handlers to allow returning values #1936. Closes Tweak closures as props to allow easier lazy values #1968

2. You can use async blocks in built in event handlers but not in user created event handlers. This code snippet seems like it should compile, but it doesn't in the main branch of dioxus:

TakesEventHandler { onclick: |event| async move {
    println!("{event:?}");
} }

This PR fixes that discrepancy. The docs that were added in DioxusLabs/docsite#275 should be updated in the next release

3. If you manually create an EventHandler or accept an EventHandler through props, you currently can't pass it directly to an element. This PR fixes that issue:

let onclick = EventHandler::new(|_| {});
rsx! { button { onclick } }

Fixes #1839

Example with new features

fn app() -> Element {
    let mut todos = use_signal(String::new);
    rsx! {
        input {
            // Normal event handlers still work without explicit type annotations
            oninput: move |evt| todos.set(evt.value()),
        }
        button {
            // async event handlers are also still supported
            onclick: |event| async move {
                tokio::time::sleep(std::time::Duration::from_secs(1)).await;
                println!("{event:?}");
            },
        }

        // New! You can now use async closures for custom event handlers!
        TakesEventHandler { onclick: |event| async move {
            println!("{event:?}");
        } }
        // Or you can accept a callback that returns a value (event handlers can still have any name they want)
        TakesEventHandlerWithArg { double: move |value| value * 2 }
    }
}

#[component]
fn TakesEventHandler(onclick: EventHandler<MouseEvent>) -> Element {
    rsx! {
        button {
            // You can pass in EventHandlers directly to events
            onclick: onclick,
            "Click!"
        }
        button {
            // Or use the shorthand syntax
            onclick,
            "Click!"
        }
    }
}

#[component]
fn TakesEventHandlerWithArg(double: Callback<u32, u32>) -> Element {
    let mut count = use_signal(|| 2);
    rsx! {
        button {
            // Callbacks let you easily inject custom logic into your components
            onclick: move |_| count.set(double(count())),
            "{count}"
        }
    }
}