Allow identifiers to take arguments

[Emoun]

Increase the flexibility of substitution by allowing identifiers to take "arguments" that change what is substituted.

Example:

#[duplicate(
  let_var( var_name );  [ let var_name = Default::default();]
)]
fn func(){
  let_var(some_name);
  let_var(some_other_name);
}

Will expand to:

fn func(){
  let some_name = Default::default();
  let some_other_name = Default::default();
}

This issue will manage the feature for the short syntax only. A later issue will manage the same for the verbose syntax.

[Emoun]

The initial implementation will support the 3 default braces () [] {}. Later, we can add support for <> to allow the feature to be used in types.

[Emoun]

Update to the syntax:

#[duplicate(
  let_var( var_name );  [ let var_name = Default::default();]
)]
fn func(){
  let_var([some_name]);
  let_var([some_other_name]);
}

Arguments given to a substitution identifier must be wrapped in any kind of braces. This distinguishes one argument from the other.
Here is an example with multiple arguments to the same identifier:

#[duplicate(
  let_var( var_name method);  [ let var_name = MyTrait::method();]
)]
fn func(){
  let_var([some_name] [some_method]);
  let_var([some_other_name] [some_other_method]);
}

Which expands to:

fn func(){
  let some_name = MyTrait::some_method();
  let some_other_name = MyTrait::some_other_method();
}

Notice in the declaration of the identifier, the argument list is not separated by anything, just a list of identifiers.

[Emoun]

Update to the identifier argument invocation:

#[duplicate(
  let_var( var_name method);  [ let var_name = MyTrait::method();]
)]
fn func(){
  let_var([some_name], [some_method]);
  let_var([some_other_name] ,[some_other_method]);
}

When invoking a substitution identifer, the arguments must be separated by commas. This because rust will refuse to compile a list of groups (i.e. [some_name] [some_method] doesn't work, [some_name], [some_method] does.)

For now, the declaration of the identifier doesn't need commas. However, this may change in the future with a revision of the syntax.

[Emoun]

When declaring a substitution without arguments, they should be separated by commas. It's just confusing that you don't need a comma. Additionally, since all other rust code requires commas, it is muscle memory to add them, and causes confusion when duplicate fails because of their presence.