Rethink the hook API

[bikeshedder]

Working with hooks is somewhat annoying. It gets worse when mixing it with sync code. See:

#363 (reply in thread)

Rather than using a closure API it might actually make sense to move to a trait API like that:

trait AsyncHook<T> {
    fn hook(
        &self,
        obj: &mut Self::Type,
        metrics: &Metrics,
    ) -> impl Future<Output = Result<(), HookError> + Send;
}

That would also allow writing reuseable hooks in a more concise way:

struct MaxAgeHook {
   max_age: Duration
}

impl MaxAgeHook {
    pub fn new(max_age: Duration) -> Self {
        Self { max_age }
    }
}

impl AsyncHook<T> for MaxAgeHook<T> {
    async fn hook(&self, _: T, metrics: Metrics) -> Result<(), HookError> {
       if metrics.age() > self.max_age {
            return Err(HookError::message("Discard object that reached its maximum age");
       }
       Ok(())
    }
}

Also the separation between async_fn and sync_fn was done to allow for some optimizations that makes it possible to skip any extra allocations needed because of boxed futures. As it turns out sync_fn sounds a lot like it allows blocking code to be written while it's actually just meant for code that doesn't need to call await.