stop gensym identifiers hijacking routine decl names in templates

[metagn]

fixes #23326

In a routine declaration node in a template, if the routine is marked as gensym, the compiler adds it as a new symbol to a preliminary scope of the template. If it's not marked as gensym, then it searches the preliminary scope of the template for the name of the routine, then when it matches a template parameter or a gensym identifier, the compiler replaces the name node with a symbol node of the found symbol.

This makes sense for the template parameter since it has to be replaced later, but not really for the gensym identifier, as it doesn't allow us to inject a routine with the same name as an identifier previously declared as gensym (the problem in #23326 is when this is in another when branch).

However this is the only channel to reuse a gensym symbol in a declaration, so maybe removing it has side effects. For example if we have:

proc foo(x: int) {.gensym.} = discard
proc foo(x: float) {.gensym.} = discard

it will not behave the same as

proc foo(x: int) {.gensym.} = discard
proc foo(x: float) = discard

behaved previously, which maybe allowed overloading over the gensym'd symbols.

A note to the "undeclared identifier" error message has also been added for a potential error code that implicitly depended on the old behavior might give, namely undeclared identifier: 'abc`gensym123', which happens when in a template an identifier is first declared gensym in code that doesn't compile, then as a routine which injects by default, then the identifier is used.

[metagn]

The breaks are from arraymancer:

https://github.com/mratsim/Arraymancer/blob/7d6d21cbcafda25201f4fd2fb481fb1316704813/src/arraymancer/tensor/private/p_accessors.nim#L217-L220

This is even in this module's documentation:

when getSubType(t) is KnownSupportsCopyMem:
  let data = t.unsafe_raw_offset()
else:
   template data: untyped = t

The compiler makes a new gensym in the let statement, ignores the template symbol, uses the gensym let symbol in later code, but the let statement is not compiled on instantiation, only the template symbol is, and the output code refers to the nonexistant gensym symbol, giving the error message "undeclared identifier data`12345".

It works when declaring the template gensym which is probably also the correct choice, but this is still an annoying break. Maybe we could get a better error message by detecting if an undeclared identifier error is about a gensym and add ", maybe a gensym symbol in a when statement was not compiled", and warn about mixing gensym and injected symbols in documentation, or just about undeclared gensym symbols in general (when false: let x {.gensym.} = ...).

As mentioned in #23326 we could also require an explicit inject for ths new behavior and keep the old behavior for no inject. But this means the compiler distinguishes between implicit and explicit injects which is harder to reason about. Or we "infer" a routine to be gensym if a gensym symbol with its name exists, but this is also weird, though maybe these are the same thing since they would both mirror the current behavior.

[github-actions]

Thanks for your hard work on this PR!
The lines below are statistics of the Nim compiler built from 73b0b0d

Hint: mm: orc; opt: speed; options: -d:release
178523 lines; 8.399s; 753.098MiB peakmem