Make nested `html!` invocations lazy

[mattfbacon]

Related to #373.

For patterns like this:

fn body() -> Markup { ... }

html! {
  h1 { "My page" }
  main { (body()) }
}

There is technically no need for the intermediate buffer from body, because the markup could render directly into the outer buffer.

In my ideal API, Markup would just implement Render (the render method would have to return something other than Markup, probably just PreEscaped<String>) and take advantage of the existing render_to method.

[nikvoid]

In my project (using #373) I solved it like this:

/// Helper for writing nested html_to!
/// Basically a lazy html! that can be rendered(-to) on demand
macro_rules! html_in {
    ($($tt:tt)*) => {
        MaudFnWrapper(|buf: &mut String| maud::html_to!{ buf, $($tt)* })
    };
}

/// A bit of closure magic to work around nested html_to!
struct MaudFnWrapper<F>(F);
impl<F> Render for MaudFnWrapper<F> 
where F: Fn(&mut String) {
    fn render_to(&self, buffer: &mut String) {
        self.0(buffer)
    }
}

Howerer this is mainly a workaround, than proper solution.

[mattfbacon]

Cool! I'll take a look at that and maybe make a PoC of my idea.

[imbolc]

Implemented in Hypertext. How difficult would it be to use the same approach in Maud?

[lambda-fairy]

It's probably fine. I think I was originally concerned about ergonomics around lifetimes, but the fact that other libraries don't care, as well as improvements on the Rust side, makes that concern unfounded. We'll still need to decide between Fn / FnMove though, and I'd like to get #412 landed first.