[Observation]Add a few clarifications and refinements to address the last bits of feedback for the review thread (#2874)

Author: phausler

proposals/0475-observed.md

@@ -173,7 +173,7 @@ Task.detached {
 }
 ```
 
-In this case both tasks will get the same values upon the same events. This can 
+In this case both tasks will get consistently safe accessed values. This can 
 be achieved without needing an extra buffer since the suspension of each side of 
 the iteration are continuations resuming all together upon the accessor's 
 execution on the specified isolation. This facilitates subject-like behavior 
@@ -257,6 +257,12 @@ composition of potentially failable systems. Any thrown error will mean that the
 terminate with that given failure. Subsequent calls then to `next` on those 
 iterators will return `nil` - indicating that the iteration is complete. 
 
+The type `Observations` will conform to `AsyncSequence`. This means that it
+adheres to the cancellation behavior of other `AsyncSequence` types; if the task
+is cancelled then the iterator will return nil, and any time it becomes 
+terminal for any reason that sequence will remain terminal and continue returning nil. 
+Termination by cancellation however is independent for each instance. 
+
 ## Behavioral Notes
 
 There are a number of scenarios of iteration that can occur. These can range from production rate to iteration rate differentials to isolation differentials to concurrent iterations. Enumerating all possible combinations is of course not possible but the following explanations should illustrate some key usages. `Observations` does not make unsafe code somehow safe - the concepts of isolation protection or exclusive access are expected to be brought to the table by the types involved. It does however require the enforcements via Swift Concurrency particularly around the marking of the types and closures being required to be `Sendable`. The following examples will only illustrate well behaved types and avoid fully unsafe behavior that would lead to crashes because the types being used are circumventing that language safety.
@@ -351,7 +357,7 @@ The result of the observation may print the following output, but the primary pr
 3 3
 ```
 
-This case dropped the last value of the iteration because the accumulated differential exceeded the production; however the potentially confusing part here is that the sleep in the iterate competes with the scheduling in the emitter. This becomes clearer of a relationship when the boundaries of isolation are crossed.
+The last value is never observed because the program ends before it would be. If the program did not terminate then another value would be observed.
 
 Observations can be used across boundaries of concurrency. This is where the iteration is done on a different isolation than the mutations. The types however are accessed always in the isolation that the creation of the Observations closure is executed. This means that if the `Observations` instance is created on the main actor then the subsequent calls to the closure will be done on the main actor.