infer_return_type: simplify definition, use less-private interface

The `Base.promote_op` function seems to be less private of an interface
than `Compiler.return_type`. While the single method defined in `Base`
basically just forwards to `Compiler.return_type` (for the purposes of
StableTasks), the semantics are a bit different because a handful of
packages actually add other methods to this function. That seems like
a good thing, though.

While at it, also avoid defining a new function, instead just assign
the callable to a constant binding. Should help code coverage.

Author: nsajko

src/internals.jl

@@ -2,18 +2,14 @@ module Internals
 
 import StableTasks: @spawn, @spawnat, @fetch, @fetchfrom, StableTask, AtomicRef
 
-if (
-    (@isdefined Core) &&
-    (Core isa Module) &&
-    isdefined(Core, :Compiler) &&
-    (Core.Compiler isa Module) &&
-    isdefined(Core.Compiler, :return_type) &&
-    applicable(Core.Compiler.return_type, identity, Tuple{})
+const infer_return_type = if (
+    isdefined(Base, :promote_op) &&
+    applicable(Base.promote_op, rand)
 )
-    infer_return_type(@nospecialize f::Any) = Core.Compiler.return_type(f, Tuple{})
+    Base.promote_op
 else
     # safe conservative fallback to `Any`, which is subtyped by each type
-    infer_return_type(@nospecialize f::Any) = Any
+    Returns(Any)
 end
 
 Base.getindex(r::AtomicRef) = @atomic r.x