Consistently use "the Swift standard library".

Confirmed no stragglers by running:

    git grep -i 'the standard library'

Author: amartini51

TSPL.docc/LanguageGuide/AdvancedOperators.md

@@ -905,14 +905,14 @@ By default, custom classes and structures don't have an implementation of
 the *equivalence operators*,
 known as the *equal to* operator (`==`) and *not equal to* operator (`!=`).
 You usually implement the `==` operator,
-and use the standard library's default implementation of the `!=` operator
+and use the Swift standard library's default implementation of the `!=` operator
 that negates the result of the `==` operator.
 There are two ways to implement the `==` operator:
 You can implement it yourself,
 or for many types, you can ask Swift to synthesize
 an implementation for you.
 In both cases,
-you add conformance to the standard library's `Equatable` protocol.
+you add conformance to the Swift standard library's `Equatable` protocol.
 
 You provide an implementation of the `==` operator
 in the same way as you implement other infix operators:
@@ -1488,7 +1488,7 @@ see <doc:Attributes#resultBuilder>.
    only if there's an implementation of the operator for that type.
    You use ``Self`` to refer to the type that will conform to the protocol,
    just like you do in other protocol requirements.
-   For example, the standard library defines the ``Equatable`` protocol
+   For example, the Swift standard library defines the ``Equatable`` protocol
    which requires the ``==`` operator:
 
    .. testcode:: protocolOperator

TSPL.docc/LanguageGuide/ClassesAndStructures.md

@@ -306,7 +306,7 @@ This means that any structure and enumeration instances you create ---
 and any value types they have as properties ---
 are always copied when they're passed around in your code.
 
-> Note: Collections defined by the standard library
+> Note: Collections defined by the Swift standard library
 > like arrays, dictionaries, and strings
 > use an optimization to reduce the performance cost of copying.
 > Instead of making a copy immediately,
@@ -694,7 +694,7 @@ but isn't a direct pointer to an address in memory,
 and doesn't require you to write an asterisk (`*`)
 to indicate that you are creating a reference.
 Instead, these references are defined like any other constant or variable in Swift.
-The standard library provides pointer and buffer types
+The Swift standard library provides pointer and buffer types
 that you can use if you need to interact with pointers directly ---
 see [Manual Memory Management](https://developer.apple.com/documentation/swift/swift_standard_library/manual_memory_management).
 

TSPL.docc/LanguageGuide/Generics.md

@@ -1733,7 +1733,7 @@ but requires one extension per requirement.
 You can include a generic `where` clause on an associated type.
 For example, suppose you want to make a version of `Container`
 that includes an iterator,
-like what the `Sequence` protocol uses in the standard library.
+like what the `Sequence` protocol uses in the Swift standard library.
 Here's how you write that:
 
 ```swift
@@ -1781,7 +1781,7 @@ The `makeIterator()` function provides access to a container's iterator.
 
    that accepts a ranged of indexes it its subscript
    and returns a subcontainer ---
-   similar to how ``Collection`` works in the standard library.
+   similar to how ``Collection`` works in the Swift standard library.
 
    .. testcode:: associatedTypes-subcontainer
 
@@ -1942,7 +1942,7 @@ This generic subscript is constrained as follows:
 
 - The generic parameter `Indices` in angle brackets
   has to be a type that conforms to the `Sequence` protocol
-  from the standard library.
+  from the Swift standard library.
 - The subscript takes a single parameter, `indices`,
   which is an instance of that `Indices` type.
 - The generic `where` clause requires

TSPL.docc/LanguageGuide/Protocols.md

@@ -2512,7 +2512,7 @@ you can define an extension to the `Collection` protocol
 that applies to any collection whose elements conform
 to the `Equatable` protocol.
 By constraining a collection's elements to the `Equatable` protocol,
-a part of the standard library,
+a part of the Swift standard library,
 you can use the `==` and `!=` operators to check for equality and inequality between two elements.
 
 ```swift

TSPL.docc/LanguageGuide/StringsAndCharacters.md

@@ -1161,7 +1161,7 @@ welcome.removeSubrange(range)
 -->
 
 <!--
-  TODO: Find and Replace section, once the standard library supports finding substrings
+  TODO: Find and Replace section, once the Swift standard library supports finding substrings
 -->
 
 > Note: You can use the `insert(_:at:)`, `insert(contentsOf:at:)`,

TSPL.docc/ReferenceManual/Declarations.md

@@ -3486,7 +3486,7 @@ binds more tightly to its operands.
 > can't be used next to each other without grouping parentheses.
 
 Swift defines numerous precedence groups to go along
-with the operators provided by the standard library.
+with the operators provided by the Swift standard library.
 For example, the addition (`+`) and subtraction (`-`) operators
 belong to the `AdditionPrecedence` group,
 and the multiplication (`*`) and division (`/`) operators
@@ -3518,7 +3518,7 @@ The *assignment* of a precedence group specifies the precedence of an operator
 when used in an operation that includes optional chaining.
 When set to `true`, an operator in the corresponding precedence group
 uses the same grouping rules during optional chaining
-as the assignment operators from the standard library.
+as the assignment operators from the Swift standard library.
 Otherwise, when set to `false` or omitted,
 operators in the precedence group follows the same optional chaining rules
 as operators that don't perform assignment.

TSPL.docc/ReferenceManual/Statements.md

@@ -422,7 +422,7 @@ they reserve the right to add new enumeration cases,
 and any code that interacts with that enumeration
 *must* be able to handle those future cases without being recompiled.
 Code that's compiled in library evolution mode,
-code in the standard library,
+code in the Swift standard library,
 Swift overlays for Apple frameworks,
 and C and Objective-C code can declare nonfrozen enumerations.
 For information about frozen and nonfrozen enumerations,
@@ -442,7 +442,7 @@ added a new case to the enumeration
 that doesn't have a corresponding switch case.
 
 The following example switches over all three existing cases of
-the standard library's [`Mirror.AncestorRepresentation`](https://developer.apple.com/documentation/swift/mirror/ancestorrepresentation)
+the Swift standard library's [`Mirror.AncestorRepresentation`](https://developer.apple.com/documentation/swift/mirror/ancestorrepresentation)
 enumeration.
 If you add additional cases in the future,
 the compiler generates a warning to indicate