Support function calls

[Senzaki]

This allows function calls in templates. There are multiple ways a function could be called: static callables (e.g. static functions), methods on template (in an impl block) and function pointer calls (template has an attribute of type e.g. FnOnce(args) -> String).

I tried to be consistent with the ways things are right now: i.e. {{ var }} refers to an attribute of the template, and path::CONST refers to a constant declared in the path module.

Case 1 : callable is an attribute of Template.

#[derive(Template)]
#[template(source = "{{ callable(123) }}", ext = "txt")]
struct Template {
    callable: fn(u32) -> String,
}

Case 2: callable is in the outer context (e.g. static function)

fn callable(val: u32) -> String {
    format!("{}", val)
}

#[derive(Template)]
#[template(source = "{{ self::callable(123) }}", ext = "txt")]
struct Template;

Case 3: callable is a method:
Actually, methods are just static functions that take &self as an argument.

#[derive(Template)]
#[template(source = "{{ Self::callable(self, 123) }}", ext = "txt")]
struct Template;

impl Template {
    fn callable(&self, val: u32) -> String {
        format!("{}", val)
    }
}

This last case might seem weird at first, but it actually keeps things consistent in the mind of the programmer, i.e. {{ var }} refers to an attribute of the template and {{ path::var }} refers to something else.

I also need to update the documentation to explain this simply.

Fixes #285, fixes #196

EDIT: Removed reference to an issue that this does not actueally address.

[djc]

This looks solid, thanks for fixing all those bugs! Some minor nits below.

[djc]

You can just silence the clippy warnings by attaching allow() attributes to the problematic functions. Thanks!

[Senzaki]

There were no good reason for me not to use _visit_args indeed! However, I could not figure out why method calls needed to be scoped in _visit_args (e.g. &{ self.a.call() } instead of &self.a.call()), but I suppose if this had to be done for method calls, I should add it for function calls as well?
Anyway, this should work, and thanks for the awesome crate!

[djc]

However, I could not figure out why method calls needed to be scoped in _visit_args (e.g. &{ self.a.call() } instead of &self.a.call()), but I suppose if this had to be done for method calls, I should add it for function calls as well?

I think so too! I don't remember off the top of my head, but I think some kinds of expressions will introduce temporary variables, and the scopes are used to make sure those are cleaned up again.

Thanks for your contribution!