Remove (only) extraneous X<> index markers

Also fix a link to a class.

Closes #4496

Author: coke

doc/Language/variables.rakudoc

@@ -480,7 +480,6 @@ hierarchical data structure through C<$=pod>.
 Note that all those C<$=someBlockName> support the L<C<Positional>|/type/Positional> and the
 L<C<Associative>|/type/Associative> roles.
 
-X<|Syntax,$~>
 =head2 The C<~> twigil
 
 The C<~> twigil is for referring to sublanguages (called slangs). The
@@ -1018,8 +1017,6 @@ stay as 84 because the block returns a defined value (C<say> returns
 C<True>). Otherwise the C<die> statement will cause the block to exit
 unsuccessfully, resetting the answer to 42.
 
-X<|Syntax,constant (Prefix)>
-X<|Language,constants (syntax)>
 =head2 The C<constant> prefix
 
 The C<constant> prefix declares that the value it tags is not going to change
@@ -1358,7 +1355,7 @@ C<META6.json> file:
 
 Every resource file is added to an B<installed> Distribution and is
 accessible using a L<C<Hash>|/type/Hash>-like access to C<%?RESOURCES>, returning a
-C<Distribution::Resource> object:
+L<C<Distribution::Resource>|/type/Distribution::Resource> object:
 
 =begin code
 my $foo-IO = %?RESOURCES<images/foo.jpg>;          # gets an object you can slurp
@@ -1552,15 +1549,13 @@ for examples and more context.
 
 C<@*ARGS> is an array of L<C<Str>|/type/Str> containing the arguments from the command line.
 
-X<|Variables,&*ARGS-TO-CAPTURE>
 =head4 C<&*ARGS-TO-CAPTURE>
 
 A dynamic variable available inside any custom
 L<C<ARGS-TO-CAPTURE>|/language/create-cli#sub_ARGS-TO-CAPTURE> subroutine
 that can be used to perform the default argument parsing. Takes the same
 parameters as are expected of the custom C<ARGS-TO-CAPTURE> subroutine.
 
-X<|Variables,&*GENERATE-USAGE>
 =head4 C<&*GENERATE-USAGE>
 
 A dynamic variable available inside any custom
@@ -1589,26 +1584,22 @@ Standard error filehandle, AKA I<STDERR>.
 These dynamic variables contain information related to the environment the
 script or program is running in.
 
-X<|Variables,%*ENV>
 =head4  C<%*ENV>
 
 Operating system environment variables. Numeric values are provided
 as L<allomorphs|/language/glossary#Allomorph>.
 
-X<|Variables,$*REPO>
 =head4 C<$*REPO>
 
 This variable holds information about modules installed/loaded.
 
-X<|Variables,$*INIT-INSTANT>
 =head4 C<$*INIT-INSTANT>
 
 C<$*INIT-INSTANT> is an L<C<Instant>|/type/Instant> object representing program
 startup time. In particular, this is when the core code starts up, so the value
 of C<$*INIT-INSTANT> may be a few milliseconds earlier than C<INIT now> or even
 C<BEGIN now> executed in your program.
 
-X<|Variables,$*TZ>
 =head4 C<$*TZ>
 
 C<$*TZ> is a dynamic variable intended to contain an object with information
@@ -1620,20 +1611,17 @@ further information, set the first time C<$*TZ> is accessed.  Any
 daylight saving time changes occurring during the duration of the
 process will B<not> be seen in that case.
 
-X<|Variables,$*CWD>
 =head4 C<$*CWD>
 
 It contains the C<C>urrent C<W>orking C<D>irectory.
 
-X<|Variables,$*KERNEL>
 =head4 C<$*KERNEL>
 
 C<$*KERNEL> contains a L<C<Kernel> instance|/type/Kernel>, the C<.gist> of it
 being the current running kernel.
 
     say $*KERNEL; # OUTPUT: «linux (4.4.92.31.default)␤»
 
-X<|Variables,$*DISTRO>
 =head4 C<$*DISTRO>
 
 This object (of type L<C<Distro>|/type/Distro>) contains information about the current operating
@@ -1662,7 +1650,6 @@ useful to create portable programs, such as the path separator:
     #          signature => Blob, desc => "2018-12-13T08:50:59.213619+01:00")␤»
 
 
-X<|Variables,$*VM>
 =head4 C<$*VM>
 
 This variable contains the current virtual machine running the code, as well as
@@ -1682,7 +1669,6 @@ configuration values used to create the virtual machine, e.g.
 which are the version of the virtual machine, generally the same one as the one
 used in the interpreter and the overall Raku environment.
 
-X<|Variables,$*RAKU>
 =head4 C<$*RAKU>
 
 This object of the L<C<Raku>|/type/Raku> class contains information on the
@@ -1703,38 +1689,32 @@ B<Note:> Before Rakudo release 2020.1, this information was only
 available through the C<$*PERL> variable. Since Rakudo release 2020.1,
 it is available through both the C<$*RAKU> and the C<$*PERL> variables.
 
-X<|Variables,$*PERL>
 =head4 C<$*PERL>
 
 For the foreseeable future, the same as C<$*RAKU>.  Will be deprecated at
 some point.
 
-X<|Variables,$*PID>
 =head4 C<$*PID>
 
 Object containing an integer describing the current Process IDentifier
 (operating system dependent).
 
-X<|Variables,$*PROGRAM-NAME>
 =head4 C<$*PROGRAM-NAME>
 
 This contains the path to the current executable as it was entered on the
 command line, or C<-e> if raku was invoked with the -e flag.
 
-X<|Variables,$*PROGRAM>
 =head4 C<$*PROGRAM>
 
 Contains the location (in the form of an L<C<IO::Path>|/type/IO::Path> object) of the Raku
 program being executed.
 
-X<|Variables,&*EXIT>
 =head4 C<&*EXIT>
 
 This is a L<C<Callable>|/type/Callable> that contains the code that will be
 executed when doing an C<exit()> call.  Intended to be used in situations where
 Raku is embedded in another language runtime (such as Inline::Perl6 in Perl).
 
-X<|Variables,$*EXIT>
 =head4 C<$*EXIT>
 
 Using C<$*EXIT> usually only makes sense in an L<END|/language/phasers#END>
@@ -1744,7 +1724,6 @@ C<exit(N)> was executed.
 
 Support for C<$*EXIT> was added in Rakudo compiler release 2023.02.
 
-X<|Variables,$*EXCEPTION>
 =head4 C<$*EXCEPTION>
 
 Using C<$*EXCEPTION> usually only makes sense in an L<END|/language/phasers#END>
@@ -1754,20 +1733,17 @@ type object otherwise.
 
 Support for C<$*EXCEPTION> was added in Rakudo compiler release 2023.02.
 
-X<|Variables,$*EXECUTABLE>
 =head4 C<$*EXECUTABLE>
 
 Contains an L<C<IO::Path>|/type/IO::Path> absolute path of the raku executable that is currently
 running.
 
-X<|Variables,$*EXECUTABLE-NAME>
 =head4 C<$*EXECUTABLE-NAME>
 
 Contains the name of the Raku executable that is currently running. (e.g.
 raku-p, raku-m). Favor C<$*EXECUTABLE> over this one, since it's not
 guaranteed that the raku executable is in C<PATH>.
 
-X<|Variables,$*USAGE>
 =head4 C<$*USAGE>
 
 This is an object of type L<C<Str>|/type/Str> containing the default usage message
@@ -1781,33 +1757,28 @@ sub MAIN($a, :$b, UInt :$ehehe) {
 
 It is accessible only inside of MAIN sub.
 
-X<|Variables,$*USER>
 =head4 C<$*USER>
 
 An L<C<Allomorph>|/type/Allomorph> with information about the user that is running the program. It
 will evaluate to the username if treated as a string and the numeric user id if
 treated as a number.
 
-X<|Variables,$*GROUP>
 =head4 C<$*GROUP>
 
 An L<C<Allomorph>|/type/Allomorph> with the primary group of the user who is running the program.
 It will evaluate to the groupname only if treated as a string and the numeric
 group id if treated as a number.
 
-X<|Variables,$*HOMEDRIVE>
 =head4 C<$*HOMEDRIVE>
 
 Contains information about the "home drive" of the user that is running the
 program on Windows. It's not defined in other operating systems.
 
-X<|Variables,$*HOMEPATH>
 =head4 C<$*HOMEPATH>
 
 Contains information about the path to the user directory that is running the
 program on Windows. It's not defined in other operating systems.
 
-X<|Variables,$*HOME>
 =head4 C<$*HOME>
 
 Contains an L<C<IO::Path>|/type/IO::Path> object representing the "home directory" of the user
@@ -1816,27 +1787,23 @@ that is running the program. Uses V«%*ENV<HOME>» if set.
 On Windows, uses V«%*ENV<HOMEDRIVE> ~ %*ENV<HOMEPATH>». If the home directory
 cannot be determined, it will be L<C<Any>|/type/Any>.
 
-X<|Variables,$*SPEC>
 =head4 C<$*SPEC>
 
 Contains the appropriate L<C<IO::Spec>|/type/IO::Spec> sub-class for the platform that the program
 is running on. This is a higher-level class for the operating system; it will
 return C<Unix>, for instance, in the case of Linux (in the form of the
 L<C<IO::Spec>|/type/IO::Spec> class used for the current implementation).
 
-X<|Variables,$*TMPDIR>
 =head4 C<$*TMPDIR>
 
 This is an L<C<IO::Path>|/type/IO::Path> object representing the "system temporary directory" as
 determined by L«C<.tmpdir IO::Spec::* method>|/routine/tmpdir».
 
-X<|Variables,$*THREAD>
 =head4 C<$*THREAD>
 
 Contains a L<C<Thread>|/type/Thread> object representing the currently executing
 thread.
 
-X<|Variables,$*SCHEDULER>
 =head4 C<$*SCHEDULER>
 
 This is a L<C<ThreadPoolScheduler>|/type/ThreadPoolScheduler> object representing
@@ -1853,7 +1820,6 @@ create a scoped copy with the default changed before using them:
 
 This behavior is not tested in the spec tests and is subject to change.
 
-X<|Variables,$*SAMPLER>
 =head4 C<$*SAMPLER>
 
 The current L<C<Telemetry::Sampler>|/type/Telemetry::Sampler> used for making snapshots of system state.
@@ -1864,19 +1830,16 @@ Only available if L<C<Telemetry>|/type/Telemetry> has been loaded.
 These variables affect the behavior of certain functions, and in some cases its
 value can be changed during runtime.
 
-X<|Variables,$*DEFAULT-READ-ELEMS>
 =head4 C<$*DEFAULT-READ-ELEMS>
 
 Affects the number of bytes read by default by
 L<C<IO::Handle.read>|/type/IO::Handle#method_read>. Its default value is 65536.
 
-X<|Variables,$*COLLATION>
 =head4 C<$*COLLATION>
 
 This is a L<C<Collation>|/type/Collation> object that can be used to
 configure Unicode collation levels.
 
-X<|Variables,$*RAT-OVERFLOW>
 =head4 C<$*RAT-OVERFLOW>
 
 Available as of release 2022.02 of the Rakudo compiler.
@@ -1921,7 +1884,6 @@ class ZeroOrInf {
 }
 =end code
 
-X<|Variables,$*TOLERANCE>
 =head4 C<$*TOLERANCE>
 
 Variable used by the L<C<=~=>|/routine/=~=> operator, and any operations that