While implementing #505 over my previous version of fixing #507 (#509), I noticed that there is a much better way which actually fixes both at the same time.

The local MapChain now keeps track of:

• variables (declaration, definition, with reference)
• caller aliases ("variables" assigned from either caller or another alias) - this contains the call-site definition, as well as the call site's Context<'a> as metadata
• Blockouts - This allows "hiding" a variable from a certain scope onward.

Basic design:

When a {% call ... %} block is entered, I push caller as a LocalMeta::CallerAlias into the local map, together with the call-site Context<'a> and Call<'a> definition.

When a variable is assigned from another variable (Expr::Var(dst) = Expr::Var(src)), where the src variable is a local of type LocalMeta::CallerAlias, the variable dst will also be inserted as caller alias by simply cloning src.

When a call expression like {{ abc() }} is encountered, whose variable is a LocalMeta::CallerAlias, we have found a {{ caller() }}, or any kind of: {{ caller_alias() }}. As soon as a new local scope was created for the call into caller(), a LocalMeta::Negative is inserted into the LocalMap. With this, the caller variable is blocked from access for this scope, and any number of scopes above - until a new entry for caller is inserted in one of the upper scopes. This prohibits callers from calling themselves - which is not supported. This was previously handled by tracking active_caller - but that was not prepared for multiple layers. Due to this restructuring, the error message changed a bit - but I like the new one better.

Imho, this design is rather elegant, since it also "accidentally" is the perfect preparation for supporting the short call syntax of jinja that askama is currently missing:

{% macro test() %}    cake    {% endmacro %}
{# syntax for macro calls without caller(): #}
{{ test() }}
{% call test() %}{% endcall %}

Fixes #505.
Fixes #507.