Property contracts

@bsoetaer 
Implemented a bunch of contracts, and made some minor changes to the Contract module to avoid recursion when creating new matrices within a matrix contract method.

I verified that the contracts are being called through manual testing - changing one of the contracts (i.e. change '==' to '!=' in `regular_postcondition?` causes the corresponding tests to fail.

Note that 9 of the tests are currently failing, since I changed them to expect `MiniTest::Assertion` (what the `assert` methods throw on failure) rather than what was previously being thrown.  When we implement contracts for those methods, the tests will pass.  This is a test of not only our implementation, but our contracts as well.
This opens up the eigenclass for the specified type - in otherwords, the methods defined herein are instance methods on the type object - and only this specific type object - and not on instances of that type.

If we knew the type name, say, Foo, it would be equivalent to:
```ruby
class Foo
    @@evaluating_contract = nil
    def self.evaluating_contract
        @@evaluating_contract
    end

    def self.evaluating_contract=(value)
        @@evaluating_contract = value
    end

    def self.evaluate_contract
        unless evaluating_contract
            evaluating_contract = true
            yield
            evaluating_contract = false
        end
    end
```