Static Contracts:
-----------------

Purpose:
Static contracts are a data structure that correspond to a regular contract.
The two differences are that a static contract corresponds to a contract at a lower phase,
and that they are designed to support introspection and manipulation.

Operations:

various constructors : * -> static-contract?
Construct a static contract corresponding to a regular contract.

optimize : static-contract? [#:trusted-positive boolean? #:trusted-negative boolean?] -> static-contract?
Changes a static contract into another one that is cheaper to check. It also removes contracts
protecting a trusted side.

instantiate : static-contract? (-> A) [kind/c] -> (or/c syntax? A)
Turns a static contract into syntax that when evaluated is the corresponding contract.
The failure continuation is invoked if the translation fails to produce a contract of the right kind.

Internal Implementation Details:

A static contract is one of three things:

recursive-sc:
  This introduces bindings for recursive contracts.
recursive-sc-use:
  This is a reference to a previously introduced recursive contract.
other:
  This is a combinator or terminal contract.

These support a couple of different operations:

sc-map: Calls a function on each sub static contract, and builds up a new static contract
sc-traverse: Calls a function on each sub static contract
sc-terminal-kind: Tells whether a static contract has no subparts and has a known contract kind

These are not applicable to recursive contract; instantaite uses them in its implementation, and
directly deals with the recursive casses.

sc->contract: Turns a static contract into syntax
sc->constraints: Turns a static contract into constraints about the contract kind


