Use async closure

[touilleMan]

close #5

Note this constitutes a breaking change, and means only Rust>=1.85 is supported

Regarding the Rust>=1.85, another solution to avoid this would be to put async closure support under a feature.
This is a bit trick though: since Faction::open & TransactionBuilder::run would have two flavors of signature.

To do that there is basically three ways:

1. Duplicate Faction::open & TransactionBuilder::run bodies
2. Put Faction::open & TransactionBuilder::run body inside a macro which is called in each flavor of the functions
3. Have the async-closure flavor of Faction::open & TransactionBuilder::run internally calles the sync-closure -returning-future

    #[cfg(not(feature = "async-closure"))]
    pub async fn open<Fun, RetFut>(
        &self,
        name: &str,
        version: u32,
        on_upgrade_needed: Fun,
    ) -> crate::Result<Database<Err>, Err>
    where
        Fun: 'static + FnOnce(VersionChangeEvent<Err>) -> RetFut,
        RetFut: 'static + Future<Output = crate::Result<(), Err>> {
        self.open_internal(name, version, on_upgrade_needed).await
}

    #[cfg(feature = "async-closure")]
    pub async fn open(
        &self,
        name: &str,
        version: u32,
        on_upgrade_needed: impl AsyncFnOnce(VersionChangeEvent<Err>) -> crate::Result<(), Err> + 'static,
    ) -> crate::Result<Database<Err>, Err> {
        self.open_internal(name, version, |evt| on_upgrade_needed(evt)).await
    }

    async fn open_internal<Fun, RetFut>(
        &self,
        name: &str,
        version: u32,
        on_upgrade_needed: Fun,
    ) -> crate::Result<Database<Err>, Err>
    where
        Fun: 'static + FnOnce(VersionChangeEvent<Err>) -> RetFut,
        RetFut: 'static + Future<Output = crate::Result<(), Err>> {
        ...
    }

Solution 3 seems the most elegant, however it only works because the async closure is 'static.

If that wasn't the case we would in theory need to use a unsafe std::mem::transmute to overwrite the lifetime of the async closure before passing it to open_internal... but even this doesn't work in practice:

• In Rust each closure has it own type (i.e. two closures with the same signature are considered of different types), so turning a impl AsyncFnOnce() into a impl AsyncFnOnce() + 'static cannot be expressed as far as I'm aware (as there is no way in telling the resulting impl AsyncFnOnce() + 'static have the same size than the impl AsyncFnOnce() provided as input)
• On top of that unsafe_jar::run relies on wasm_bindgen::Closure::once which itself requires the passed closure to be 'static

[Ekleog]

LGTM! Just two small style nits, I'm committing them to your branch and merging 😄

[Ekleog]

Thank you for the PR! I'll probably release 0.5 after coming to a decision on #4 ; and having made enough progress on sakuhiki to be sure the new API works fine for me 😄