compiler: Add CaseProcedureType

This is the foundation of the reimplementation of (case-lambda). The
type has the same meaning and syntax as does in Typed Racket: it lists
the possible signatures a (case-lambda) accepts

ProcedureType and CaseProcedureType are unified by ApplicableType. Type
checking occurs at the ApplicableType level
compiler: Split ExtractModuleBodySuite

- Split the lambda related tests out in to ExtractLambdaSuite

- Rename the remaining tests to ModuleBodyExtractorSuite to match the
  name of the Scala class it's testing
compiler: Allow (case->) with 0 or 1 clauses

R7RS explicitly allows (case-lambda) to have zero or more clauses.
Add ExtractCaseLambda

This is currently non-functional. It only contains the required changes
to the frontend

- Remove (case-lambda) macro from stdlib.scm

- Add et.CaseLambda which is literally an list of et.Lambda expressions

- Add ExtractCaseLambda to parse untyped (case-lambda) expressions using
  ExtractLambda
compiler: Planning for untyped (case-lambda)

This will generate (case-lambda) entry points based off of an
et.CaseLambda expression. There are a few shortcomings currently:

- Inlining is not supported for (case-lambda). This is a major
  regression.

- We're GC rooting the rest arg value when invoking clause procedures
  even though it's unused after that point

- We don't detect arity mismatches at compile time
compiler: Support inlining (case-lambda)

Add a new IntermediateValue.toApplicableValueForArity() that
KnownCaseLambdaProc overrides to select the case clause with the
appropriate arity. This has three advantages:

- We can detect arity mismatches at compile time

- If we find an exactly matching procedure we can inline it

- If inlining doesn't work we can instead invoke the clause procedure
  directly without indirecting through the (case-lambda) procedure
compiler: Re-add tests with R7RS (case-lambda)

(case-lambda) was always fairly fragile due to its complexity. It's
useful to test the R7RS definition of (case-lambda) even if it's not
being used as our primary implementation.
compiler: Remove useless if
compiler: Support for (case-lambda:)

This uses the existing (lambda:) infrastructure to parse (case-lambda:)
clauses. Because there's no (define) form of (case-lambda) this does not
support type annotations.
compiler: Clean up and fix (ann)

Instead of passing the staticCheck flag deep in to our type conversion
functions we can simply ensure the Scheme type is satisfied at the entry
to castToSchemeType. This fixes (ann) misbehaving for prcoedure types.
compiler: Properly type (case-lambda) values

Because (case-lambda) had the signature of the TopProcedureType it's
Scheme type was (-> <any> * *). This prevented things like type
annotations from working.

Instead override the Scheme type for KnownCaseLambdaProc to build a
proper Scheme type from its clauses.
compiler: Support for square bracketed lists

This are treated identically to the traditional Lisp round bracketed
lists. They exist for two reasons:

- Compatibility with Racket

- Allowing for type annotation in (lambda:), (case-lambda:) etc to be
  more clear

These are allowed in both the R7RS and Llambda dialects. Valid R7RS
programs shouldn't contain square brackets so this isn't a report
compliance issue.
compiler: Make RetypeLambdaArgs case-lambda aware

This adds a new KnownCaseLambdaProc.clauseForArityOpt which exposes its
clause selection logic and uses it to resolve the correct clause instead
RetypeLambdaArgs
compiler: Restructure libraries

(llambda stdlib) both defined (case-lambda) and used it internally in
its definitions. This is in contrast to R7RS where (case-lambda) was a
separate library.

Now that (case-lambda) is a primitive we can structure our libraries
more closely to how they are in R7RS. Namely, everything that doesn't
add exports over R7RS is implemented directly in the "scheme" directory
while those adding exports are defined in the "llambda" directory with a
fascade library in the "scheme" directory if applicable
compiler: Fix (case-lambda) arity check

Clauses with rest arguments should always be allowed, even if they have
fewer fixed arguments than the previous clause.
compiler: Remove stale reference to (case-lambda)