Generalize function applications

[toots]

This PR improves function application type generalization. This fixes #3303.

In #3303, we discussed several cases where type generalization should and should not be done over a function application.

Here are a couple of examples:

Source type

s = single()
s : source('A)

Here, we cannot generalize the universal type of the source because it can be used with operators requiring different type of content, for instance:

enc = %ffmpeg(
  format="aac",
  %audio(codec="aac"),
)

# Here, type is source(audio=pcm)
output.file(fallible=true, enc, "/tmp/bla.mkv", s)

# Here type is source(audio=ffmpeg.copy('a))
ignore(ffmpeg.decode.audio(s))

Ref return

def f(x=null()) =
  ref(x)
end
f : (?'a?) -> (() -> 'a?).{set : ('a?) -> unit}

If we generalize the returned value of this function, we end up with a reference cell to which we can assign values of any type:

r = f()
r : (() -> 'a?).{set : ('a?) -> unit} = <fun>.{set=<fun>}
r.set(1)
r.set("aabb")

Pure function return

def f() =
  fun (x) -> x
end
f : () -> ('a) -> 'a

This one is safe to generalize:

fn = f()
fn : ('a) -> 'a

The idea

The idea here is that, if a universal type is present in the type of the returned value of the function, we should not generalize.

However, if this type is actually itself inside a function for which there is a non-optional argument containing it, then it should be safe to generalize.

The reason being that, if we generalize this type, it will be unified with any future application of the function it belongs to therefore making the type generalization safe.

Other examples:

# Type generalization with a method:
def f() =
  fun (x) -> { foo = x }
end
fn = f()
fn : ('a) -> {foo : 'a}

def f() =
  fun (x) -> {foo = x.gni }
end
fn : ('b.{gni : 'a}) -> {foo : 'a}

# With a tuple:
def f() =
   def g(x) =
    let (y, _) = x
    y
  end
  g
end
fn : (('a * 'b)) -> 'a

Etc.

[toots]

Gonna merge this. I think it's safe and we can revisit if it causes trouble, it's pretty isolated.