De-anonymize patvar in given pattern

[som-snytt]

Fixes #23119

A given pattern in a for comprehension results in a fresh val in the body of the mapping function, but is not correlated with patvars.

This commit gives the given its usual given name (in makeIdPat) so that the unused check can check it.

A subsequent pattern var is named when typechecked, which resulted in the warning.

The fix adds the PatternVar attachment in makeIdPat and also fixes the tree pos, so that it corresponds to the position of the pat var in the elaboration of the for (that is, the position of the given T tree).

The unused check can now detect the patvar using the attachment and use the tree pos (instead of the bind name pos).

Adds some mild refactoring to name subexpressions and reduce line lengths.

[som-snytt]

The analysis relies on ignoring derived names and also correlating pattern vars by position.

The existing artifact received a "fresh" name and a zero-extent synthetic position.

[som-snytt]

The gods would often appear in disguise -- probably one may say more precisely that they were present but did not appear -- and in fact, the Easter story tells us that they didn't recognize Jesus, though maybe that was because they were not expecting him.

Did you know that the incognito gods dwell on Mount Anonympus?

In English, the given name is a Vorname, Taufname, which, one discovers as a parent, is also invented.

[som-snytt]

I would like to settle on conventions for "refining" patterns.

I changed names in the match:

      def makeIdPat(pat: Tree): (Tree, Ident) = pat match
        case pat @ Bind(nme.WILDCARD, body) =>
          val name =
            body match
            case Typed(Ident(nme.WILDCARD), tpt) if pat.mods.is(Given) => inventGivenName(tpt)
            case _ => UniqueName.fresh()
          cpy.Bind(pat)(name, body)
            .withMods(pat.mods)
          ->
          Ident(name)

where pat has the same referent and body refers to the nested tree and is the canonical name (if not descriptive here).

Previously, case bind @ Bind(x, pat) => was confusing. I would like a lint to tell me that it is confusing. All the symbols are "used", and it's normally ok to rebind pat to a subpattern, but maybe not if the original pat is also aliased.

This is the other example, where it used to say pat and pat1, which were not aliases:

      def isVarBinding(pat: Tree): Boolean = pat match
        //case pat @ Bind(_, pat1) if pat.mods.is(Given) => isVarBinding(pat1)
        case bind @ Bind(_, pat) if bind.mods.is(Given) => isVarBinding(pat)
        case pat @ Bind(_, body) if pat.mods.is(Given) => isVarBinding(body) // edit to this instead

I should certainly not introduce the alias bind.