AsyncStream: Explicit code-block fence around doc code snippet. (#41407)

* Explicit code-block fence around doc code snippet.

* Doc snippet: remove unnecessary indentation.

Co-authored-by: Chris Adamson <cadamson@apple.com>

Author: invalidname

stdlib/public/Concurrency/AsyncStream.swift

@@ -68,21 +68,23 @@ import Swift
 /// calls `stopMonitoring()` on the monitor.
 /// 4. Calls `startMonitoring` on the `QuakeMonitor`.
 ///
-///     extension QuakeMonitor {
+/// ```
+/// extension QuakeMonitor {
 ///
-///         static var quakes: AsyncStream<Quake> {
-///             AsyncStream { continuation in
-///                 let monitor = QuakeMonitor()
-///                 monitor.quakeHandler = { quake in
-///                     continuation.yield(quake)
-///                 }
-///                 continuation.onTermination = { @Sendable _ in
-///                     monitor.stopMonitoring()
-///                 }
-///                 monitor.startMonitoring()
+///     static var quakes: AsyncStream<Quake> {
+///         AsyncStream { continuation in
+///             let monitor = QuakeMonitor()
+///             monitor.quakeHandler = { quake in
+///                 continuation.yield(quake)
 ///             }
+///             continuation.onTermination = { @Sendable _ in
+///                  monitor.stopMonitoring()
+///             }
+///             monitor.startMonitoring()
 ///         }
 ///     }
+/// }
+/// ```
 ///
 /// Because the stream is an `AsyncSequence`, the call point can use the
 /// `for`-`await`-`in` syntax to process each `Quake` instance as the stream
@@ -265,7 +267,7 @@ public struct AsyncStream<Element> {
   /// The following example shows an `AsyncStream` created with this
   /// initializer that produces 100 random numbers on a one-second interval,
   /// calling `yield(_:)` to deliver each element to the awaiting call point.
-  /// When the `for` loop exits and the stream finishes by calling the
+  /// When the `for` loop exits, the stream finishes by calling the
   /// continuation's `finish()` method.
   ///
   ///     let stream = AsyncStream<Int>(Int.self,

stdlib/public/Concurrency/AsyncThrowingStream.swift

@@ -80,24 +80,26 @@ import Swift
 /// calls `stopMonitoring()` on the monitor.
 /// 5. Calls `startMonitoring` on the `QuakeMonitor`.
 ///
-///     extension QuakeMonitor {
+/// ```
+/// extension QuakeMonitor {
 ///
-///         static var throwingQuakes: AsyncThrowingStream<Quake, Error> {
-///             AsyncThrowingStream { continuation in
-///                 let monitor = QuakeMonitor()
-///                 monitor.quakeHandler = { quake in
-///                     continuation.yield(quake)
-///                 }
-///                 monitor.errorHandler = { error in
-///                     continuation.finish(throwing: error)
-///                 }
-///                 continuation.onTermination = { @Sendable _ in
-///                     monitor.stopMonitoring()
-///                 }
-///                 monitor.startMonitoring()
+///     static var throwingQuakes: AsyncThrowingStream<Quake, Error> {
+///         AsyncThrowingStream { continuation in
+///             let monitor = QuakeMonitor()
+///             monitor.quakeHandler = { quake in
+///                  continuation.yield(quake)
 ///             }
+///             monitor.errorHandler = { error in
+///                 continuation.finish(throwing: error)
+///             }
+///             continuation.onTermination = { @Sendable _ in
+///                 monitor.stopMonitoring()
+///             }
+///             monitor.startMonitoring()
 ///         }
 ///     }
+/// }
+/// ```
 ///
 ///
 /// Because the stream is an `AsyncSequence`, the call point uses the
@@ -289,7 +291,7 @@ public struct AsyncThrowingStream<Element, Failure: Error> {
   /// The following example shows an `AsyncStream` created with this
   /// initializer that produces 100 random numbers on a one-second interval,
   /// calling `yield(_:)` to deliver each element to the awaiting call point.
-  /// When the `for` loop exits and the stream finishes by calling the
+  /// When the `for` loop exits, the stream finishes by calling the
   /// continuation's `finish()` method. If the random number is divisble by 5
   /// with no remainder, the stream throws a `MyRandomNumberError`.
   ///