Remove the collection Expect construct.
Instead, we use generics now and substitution of
generics to deal with unification of collections.

- Ignore collection type in output
- Make temporary variables top-level

Need to augment the unification rule for types a
bit. If generics match and any generic is
temporary, these must be substituted as well.

- __iter__() call, which gives iterator.
  We constrain this using a temporary type
- __next__() call, whose return type is
  constrained to the collection type

Need to generalize how we convert mamba types
to Python types in generate stage.
In particular:
- When encountering types in the wild
- When encountering constructors in the wild

And _only_ in those situations so we don't
accidentally change identifiers with say class
names.

Makes unification logic much simpler.

Now easier to check whether something callable
or tuple.
Also simply generate by not looking at type
annotations, except for class arguments.
We are now dependent on the check stage to
annotate variables

When looking up classes in context, we convert
generic parents to concrete parents (in the form
of StringNames).

So, Collection[Int] is a super of Set[Int]:
- Set has a parent Collection[Int]
- We check that Collection[Int] is super of
  itself:
  - The first part is equal to itself.
    We also see that it has the same amount of
    generics as itself.
    - We proceed to perform this now for each
      generic by matching them.

We added extra logic to deal with:
- tuple literals
- streamlining of tuples of identifiers

Tuple matching still trips up when not matching
with tuple literals.
Perhaps we do need some logic in the unification
stage, but this should be a last resort.

Also match identifier with any expression if no
type present.

And remove unnecessary push_ty in unify_ty.

For tuples we make an exception by iterating over
the elements and checking that they each define
__str__().

Also add extra rule for self.
In union, self is always equal to entity_name.
Other arguments are left as-is.

Should restructure name such the Name can have
nested unions.