The RFC itself is not intended to be a way to sneak interpolation
into the formatting macros; the RFC author believes that they do
not need full interpolation support, although would not rule it
out if it was deemed desirable.

This update to the RFC text clarifies the distinction between
implicit named arguments and interpolation. It also adds a note
on prior art that Field Init Shorthand is an existing precedent
where language ergonomics have introduced a special case for
single identifiers.

The examples provided had incorrectly merged Scala and PHP.
Scala's string interpolation is written `s"$foo"` whereas PHP is written `"$foo"`

With thanks to Lonami, joshtriplett and tmccombs

Some discussion in the RFC about how `dotted.paths` might be
supported, especially in formatting parameters, came to the
conclusion that a new syntax would very likely be desirable. This
is added to the future work section and nominally suggests the
{(expr)} interpolation syntax to achieve this.

In RFC discussion it emerged that it was not clearly stated in the RFC
that implicit named arguments only apply if a corresponding explicit
named argument is not passed to the macro invocation.

When format_args! recieves an expression as the first argument, it
attempts to expand it to a string literal. If successful, this is
used as the format string and format_args! macro expansion continues
as usual.

This has subtle interactions with macro hygiene when implicit named
arguments come into play. This commit adds dicussion around this case.

The panic macro currently does not perform string formatting if
it only passed a single argument which is a string literal.

To be consistent with implicit named arguments and e.g.
`print!("{foo}")`, panic with a single string literal will need
to change to also use string formatting.