Changes computation expression's Return to accept only unit.

Previously, Return accepted any type at all, but ignores the value. This leads to developers writing code like `return 1` which compiles but has no run-time effect, leaving the developer very confused. This computation expression's Return was not intended to be using explicitly with a `return` keyword but was added to allow the use of `do!`.

This commit changes Return to only accept unit to no longer allow explicit calls to return passing a value, but continue to allow `do!`.

Return is being removed from the signature file because of the inability to define the correct type signature. The signature is `unit -> AsyncSeq<'T>`, but the compiler interprets this as a function that has no parameters rather than a function that has a single parameter of type unit.

Author: mattstermiller

src/FSharp.Control.AsyncSeq/AsyncSeq.fs

@@ -399,7 +399,7 @@ module AsyncSeq =
     //     do! something
     //
     // because F# translates body as Bind(something, fun () -> Return())
-    member x.Return _ = empty
+    member x.Return () = empty
     member x.YieldFrom(s:AsyncSeq<'T>) =
       s
     member x.Zero () = empty

src/FSharp.Control.AsyncSeq/AsyncSeq.fsi

@@ -91,7 +91,9 @@ module AsyncSeq =
         member For : source:AsyncSeq<'T> * action:('T -> AsyncSeq<'TResult>) -> AsyncSeq<'TResult>
 
         /// Implements "return" for the asyncSeq computation builder.
-        member Return : 'unit -> AsyncSeq<'T> 
+        // Commented because there does not seem to be a way to specify the correct parameter type to the compiler.
+        // What is needed is one parameter of type unit, but the below is interpreted as zero parameters.
+        //member Return : unit -> AsyncSeq<'T>
 
         /// Implements "try-finally" for the asyncSeq computation builder.
         member TryFinally : body:AsyncSeq<'T> * compensation:(unit -> unit) -> AsyncSeq<'T>