Relevant issues

• Resolves Constraint builder should implement branching model #436
• Resolves Type annotation cannot be unified with union types #427
• Created Constraint generation can be generalized to remove Expect::Collection construct #437

Summary

Another addition to the constraint builder, similar to #416 .
This time, we implement a new branching model which allows us to now finally properly check converging paths:

• We can mark a branch point
• Any call to a branch_from(branch point) will then create a new set.
  It will copy over all constraints from the previous set, up to the branch point.

We now only create branches for:

• If expressions
• Match expressions

This means that we don't unnecessarily create new sets when entering classes, for loops, while loops, etc.
Only when we have diverging execution paths.
Shadowing of variables is now no longer maintained partially by different sets, but instead by shadowing of variables in:

• The global scope (stored in the constraint builder)
• In the local scope, stored by the local Environment, which is used first before reverting to the global scope to lookup variables.
• This means that when we encounter a new variable we add it both to the global scope (in the constraint builder) and the local environment.
• We always lookup variables in the environment.
  This means that even if a mapping exists in the global scope, if the variable does not exist in the local environment at all then we still get an error.
  This same logic is also used when we recursively substitute identifiers within ASTs.
• Lastly, we explicitly override the self from the environment with the global mapping of self when exiting a class..

As a result of this refactor, we also moved some var mapping logic to the builder to make it easier to change.
This means that Expected::from(AST) has been greatly simplified.
In fact, there was no reason for it to return a result now.

Destruction of variables

Due to the change in behavior, we had to add destruction variables in the environment in case we are no longer allowed to access them:

• In the body of a with <resource> as <alias>, where the resource itself is now no longer accessible.

In other locations where we use a type alias we should also destruct variables.
For instance, if in match if we in future allow type aliases to be used there.

Propagate assigns

If we assign to a variable ,that variable has a type.
Normally we annotate this with a type.
We now also do this even when we propagate an assign into a match or if:

Example with if:

def my_var := if True then
    print("then")
    10
else
    print("else")
    20

Generates:

if True:
    print("then")
    my_var: int = 10
else:
    print("else")
    my_var: int = 20

Before:

if True:
    print("then")
    my_var = 10
else:
    print("else")
    my_var = 20