#9085 Complete the constructors of extensible variants

Codex review on #9085: extensions were matched to an open type by its last name only, so A.t got the constructors of B.t, and a constructor declared in a nested module was inserted without its module, which doesn't compile because an extension constructor can't be found from the expected type. An extension now records the type it extends and is matched by that type's file and stamp, and it is named by its module path, for example Sub.Flag; a prefix may match the last part.

Codex review on #9085: extension constructors were named relative to the root of their file and to the file of the completed value. Inside the declaring module that inserted Sub.Flag, which is not in scope there, and for a value imported from another file the constructors were not qualified with its module, while extensions in the edited file were missed. A completion request now records the edited file and the module path at the cursor; constructors of that file drop the module path shared with the cursor, constructors of other files get their module's name, and extensions are collected from the edited file.

Codex review on #9085: the module name of another file comes from its compiled name, which in a namespaced project is Base-MyNamespace, so completion inserted Base-MyNamespace.Flag. The name is turned into its source path MyNamespace.Base first.

Codex review on #9085: an extension of the edited file declared after the cursor was offered although it isn't in scope there, and an extension inside a module of an interface (module Sub: { type attr += Flag }) was never registered, because only typed-tree extensions were. The completion scope now records the cursor position and skips later extensions of the edited file, and extensions in signatures are registered too.

Codex review on #9085: an extension two modules deep in an interface got only the outer module in its path, because the signature walk didn't extend the module path when entering a module, and completion inside the payload of a qualified constructor such as Sub.Toggle(...) found no constructor, because the payload position keeps only Toggle. Signature modules now extend the path, and payload lookup also matches the last part of a qualified constructor name.

Codex review on #9085: a payload type declared next to the extension, as in type Base.attr += Color(color) with a local color, was resolved in the open type's file, so payload completion lost it; and of two same-named extensions, B.Value(...) completed the payload of the first one, A.Value, because the payload position kept only Value. Each extension constructor now carries the environment of its file, and the payload position keeps the written path: the constructor sharing the longest suffix with it is meant, ties going to the most recent open, then to the last declared one.

Codex review on #9085: ranking same-named extension constructors let an open outrank a local extension declared after it, so after open A and a later local Value(...), completion used A.Value's payload; and an extension inside a module type, module type S = { type attr += Phantom }, was offered as S.Phantom and added to exhaustive switches. A qualified constructor is now the one its written path names, and an unqualified one is looked up in the completion scope as the compiler does, which now records extension constructors, the most recent declaration or open winning. Extensions in module types are skipped.