Update 02_KeyTypes.md (#2189)

* Update 02_KeyTypes.md

Correct typo that said:
"Remember when I said that in an abstract sense, IObserver<T> represents the same thing as IEnumerable<T>?"
to:
"Remember when I said that in an abstract sense, IObserver<T> represents the same thing as IEnumerator<T>?"

* Update Rx.NET/Documentation/IntroToRx/02_KeyTypes.md

The intent of the original suggestion was correct, but added a new type, which this fixes

Co-authored-by: Howard van Rooijen <[email protected]>

---------

Co-authored-by: Ian Griffiths <[email protected]>
Co-authored-by: Howard van Rooijen <[email protected]>

Author: 3 people

Rx.NET/Documentation/IntroToRx/02_KeyTypes.md

@@ -287,7 +287,7 @@ If you're wondering whether the relationship between `IObservable<T>` and `IObse
 
 The difference reflects the fundamental _pull vs push_ difference between `IEnumerable<T>` and `IObservable<T>`. Whereas with `IEnumerable<T>` we ask the source to create an `IEnumerator<T>` for us which we can then use to retrieve items (which is what a C# `foreach` loop does), with `IObservable<T>`, the source does not _implement_ `IObserver<T>`: it expects _us_ to supply an `IObserver<T>` and it will then push its values into that observer.
 
-So why does `IObserver<T>` have these three methods? Remember when I said that in an abstract sense, `IObserver<T>` represents the same thing as `IEnumerable<T>`? I meant it. It might be an abstract sense, but it is precise: `IObservable<T>` and `IObserver<T>` were designed to preserve the exact meaning of `IEnumerable<T>` and `IEnumerator<T>`, changing only the detailed mechanism of consumption.
+So why does `IObserver<T>` have these three methods? Remember when I said that in an abstract sense, `IObserver<T>` represents the same thing as `IEnumerator<T>`? I meant it. It might be an abstract sense, but it is precise: `IObservable<T>` and `IObserver<T>` were designed to preserve the exact meaning of `IEnumerable<T>` and `IEnumerator<T>`, changing only the detailed mechanism of consumption.
 
 To see what that means, think about what happens when you iterate over an `IEnumerable<T>` (with, say, a `foreach` loop). With each iteration (and more precisely, on each call to the enumerator's [`MoveNext`](https://learn.microsoft.com/en-us/dotnet/api/system.collections.ienumerator.movenext) method) there are three things that could happen:
 
@@ -581,4 +581,4 @@ What if we unsubscribe early by calling `subscription.Dispose()`? In that case i
 
 Either way, everything from the source to the observer, including any operators that were sitting in between, gets shut down.
 
-Now that we understand the relationship between an `IObservable<T>` source and the `IObserver<T>` interface that received event notifications, we can look at how we might create an `IObservable<T>` instance to represent events of interest in our application.
+Now that we understand the relationship between an `IObservable<T>` source and the `IObserver<T>` interface that received event notifications, we can look at how we might create an `IObservable<T>` instance to represent events of interest in our application.