Adds target destination and some reflow

Added back /syntax/role, which disappeared due to obscure indexing
rules (see #2575). Either when indexing for `does` was
added (apparently, adding an index term behind or before a header
suppresses the creation of a new page), or simply when the
X<|declarator,role> was changed, it disappeared. It's added back, refs #2568

Author: JJ

doc/Language/objects.pod6

@@ -669,9 +669,9 @@ say RectangleWithCachedArea.new( x2 => 5, x1 => 1, y2 => 1, y1 => 0).area;
 
 =head2 Object cloning
 
-The cloning is done using the L<clone|/routine/clone> method available on all objects, which
-shallow-clones both public and private attributes. New values for I<public>
-attributes can be supplied as named arguments.
+The cloning is done using the L<clone|/routine/clone> method available on all
+objects, which shallow-clones both public and private attributes. New values for
+I<public> attributes can be supplied as named arguments.
 
     =begin code
     class Foo {
@@ -685,43 +685,47 @@ attributes can be supplied as named arguments.
     say $o2; # Foo.new(foo => 42, bar => 5000)
     =end code
 
-See document for L<clone|/routine/clone> for details on how non-scalar attributes get cloned,
-as well as examples of implementing your own custom clone methods.
+See document for L<clone|/routine/clone> for details on how non-scalar
+attributes get cloned, as well as examples of implementing your own custom clone
+methods.
 
-=head1 The X<role> declarator
-X<|does>
+=head1 X<Roles|declarator,role>
 
 Roles are a collection of attributes and methods; however, unlike classes, roles
 are meant for describing only parts of an object's behavior; this why, in
 general, roles are intended to be I<mixed in> classes and objects. In general,
 classes are meant for managing objects and roles are meant for managing behavior
 and code reuse within objects.
 
-    =begin code
-    use MONKEY-SEE-NO-EVAL;
-    role Serializable {
-        method serialize() {
-            self.perl; # very primitive serialization
-        }
-        method deserialize($buf) {
-            EVAL $buf; # reverse operation to .perl
-        }
-    }
+X<|does> Roles use the keyword C<role> preceding the name of the role that is
+declared. Roles are mixed in using the C<does> keyword preceding the name of the
+Role that is mixed in.
 
-    class Point does Serializable {
-        has $.x;
-        has $.y;
+=begin code
+use MONKEY-SEE-NO-EVAL;
+role Serializable {
+    method serialize() {
+        self.perl; # very primitive serialization
     }
-    my $p = Point.new(:x(1), :y(2));
-    my $serialized = $p.serialize;
-    my $clone-of-p = Point.deserialize($serialized);
-    say $clone-of-p.x; # OUTPUT: «1␤»
-    =end code
+    method deserialize($buf) {
+        EVAL $buf; # reverse operation to .perl
+    }
+}
+
+class Point does Serializable {
+    has $.x;
+    has $.y;
+}
+my $p = Point.new(:x(1), :y(2));
+my $serialized = $p.serialize;
+my $clone-of-p = Point.deserialize($serialized);
+say $clone-of-p.x; # OUTPUT: «1␤»
+=end code
 
 Roles are immutable as soon as the compiler parses the closing curly brace of
 the role declaration.
 
-=head2 Application of role
+=head2 Applying roles
 
 Role application differs significantly from class inheritance. When a role
 is applied to a class, the methods of that role are copied into the class.

doc/Language/operators.pod6

@@ -2585,7 +2585,7 @@ precedence.
 
 Short-circuits so that it returns the first operand that evaluates to
 C<False>, otherwise returns the last operand. Note that C<and> is easy
-to misuse. See L<traps|/language/traps#Loose_boolean_operators>.
+to misuse, see L<traps|/language/traps#Loose_boolean_operators>.
 
 =head2 infix X<C«andthen»>
 

doc/Type/Cool.pod6

@@ -6,14 +6,14 @@
 
     class Cool is Any { }
 
-C<Cool>, also known as the B<C>onvenient B<OO> B<L>oop, is a base class
-employed by a number of built-in classes whose instances can be meaningfully
-coerced to a string and a number. For example, an L<Array|/type/Array> can be used
-in mathematical operations, where its numerical representation is the
-number of elements it contains. At the same time, it can be concatenated
-to a string, where its stringy representation is all of its elements
-L<joined|/routine/join> by a space. Because L<Array|/type/Array> is L<Cool|/type/Cool>, the
-appropriate coercion happens automatically.
+C<Cool>, also known as the B<C>onvenient B<OO> B<L>oop, is a base class employed
+by a number of built-in classes whose instances can be meaningfully coerced to a
+string and a number. For example, an L<Array|/type/Array> can be used in
+mathematical operations, where its numerical representation is the number of
+elements it contains. At the same time, it can be concatenated to a string,
+where its stringy representation is all of its elements L<joined|/routine/join>
+by a space. Because L<Array|/type/Array> is L<Cool|/type/Cool>, the appropriate
+coercion happens automatically.
 
 Methods in C<Cool> coerce the invocant to a more specific type, and then call
 the same method on that type. For example both L<Int|/type/Int> and L<Str|/type/Str> inherit from