Improved const invariants

@bsoetaer 
Added new functionality for defining commonly used contracts in a single line.  'const' and 'require_square' are now implemented using this system.
As it stands, I think this is the easiest way to be able to remove the overhead of the contracts at will.  If we implement it the way Miller suggests at the end of his "Typing" slides, there's pretty much no way to disable all the contracts at once, unless there's something built in to Test::Unit::Assertions for switching them off.  And even if there is, the arguments to the assertions would still be evaluated.

This way, the contracts are all controlled by one line of code at the end of the class: `include MatrixContract`.  So for 'production' code, it's trivial to disable.

You're right about the postcondition code - but in fact for simple functions like `diagonal?`, I would expect the postcondition to _more than double_ the runtime, since the production code can be optimized depending on the type of matrix we're using.  In other words, it's a contract to the user expressed solely in terms of functions the user can access, and making no assumptions about the implementation of the Matrix.

For some of the postconditions, like the LU factorization, I would not expect the postcondition to duplicate the functionality - rather it would be something like this:

```ruby
def lup_postcondition(l, u, p)
  assert(l.lower_triangular?)
  assert(u.upper_triangular?)
  assert(p.permutation?)
  assert_equal(l * u, self * p)
end
```