Set architecture to native.

Could help the compiler with optimizations.
Fix get_row/column3/4 call sequence.
Remove RHS == output checks for Mat3/4#multiply

These weren't doing anything useful, so I removed them.
Remove Quat's normalize implementation, replace it with Vec4's.

sm_quat_normalize was broken, so this was easier than fixing it.
Fix sm_quat_multiply_vec3.

This was working despite being incorrect. Kind of weird, but I guess
that's what happens when everything's an array of floats.
Fix variable name in sm_quat_add/subtract.

Should've been RHS, was mysteriously sm_left.
Fix type compatibility stuff.

Vec4 and Quat now work anywhere a Vec3 is expected -- only the first
three components of either are read or written to. Quat and Vec4 are
more or less compatible, with the exception of things that expect Quats
as a way of representation rotations (namely Mat3 and Mat4).

Mat3 and Mat4 arrays will now implicitly convert from Mat3 to Mat4 and
vice versa when storing a value. When fetching, output still has to be
of the same type.
Fix Quat#multiply! documentation markup.

Was accidentally producing an h1. Side-effect of having a # at the head
of a line.
Add some constants for identifying various properties of the gem.

Snow::SNOW_MATH_FLOAT_SIZE -> The size in bytes of the float type used
by snow-math. Either 4 or 8, depending on whether s_float_t aliases
float or double. With this, you should be able to either a) reject the
currently installed build of snow-math if it's not the right size float
or b) alter your code to accept differently-sized floats (e.g., switch
between GL_FLOAT and GL_DOUBLE). Personally, I recommend the first
option because trying to change things like this depending on the gem
environment isn't the best of ideas.

All math types now have SIZE and LENGTH constants that identify their
size in bytes and number of components. You could do this previously by
allocating one of the objects and getting the size and length from it,
but this is a little more convenient since it saves on an allocation.

All typed arrays now have a TYPE constant that reports their underlying
type. So, Mat3Array::TYPE is Mat3, Vec4Array::TYPE is Vec4, and so on.
Version 1.3.0

New constants:

  * Snow::SNOW_MATH_FLOAT_SIZE -- the size in bytes of the float type
    snow-math uses. Either 4 or 8.

  * Snow::Vec3::SIZE and ::LENGTH,
    Snow::Vec4::SIZE and ::LENGTH,
    Snow::Quat::SIZE and ::LENGTH,
    Snow::Mat3::SIZE and ::LENGTH,
    Snow::Mat4::SIZE and ::LENGTH ---
      These all report the same data that each object's #size
      and #length methods do. They're just there to be more convenient.
      These constants aren't provided for the Array types for the
      obvious reason that their lengths and sizes are variable.

  * Snow::Vec3Array::TYPE,
    Snow::Vec4Array::TYPE,
    Snow::QuatArray::TYPE,
    Snow::Mat3Array::TYPE,
    Snow::Mat4Array::TYPE ---
      These all refer to the underling type of the array class.
      Vec3Array::TYPE is Vec3, Mat4Array::TYPE is Mat4, and so on.

Changes in behaviour:

  - Mat3Array and Mat4Array now implicitly convert Mat3/Mat4 to their
    container's type on store. So, Mat4Array.[4][0] = Mat3[] will
    convert the Mat3 to a Mat4.

  - Where a Quat is expected, you can also provide a Vec4, and vice
    versa. Where a Vec3 is expected, you can provide a Vec3, Vec4, or
    Quat and only the first three components of either a Vec4 or Quat
    will be read from/written to.

  - snow-math is now compiled for the native architecture. This is so
    the compiler has a chance to do whatever optimizations it can given
    the environment (e.g., SSE optimizations and so on).

  - You now have the option of building the gem with -ffast-math on by
    passing --use-fast-math to `gem install`. This is still disabled by
    default.

*** 1.3.0pre0 Notes ***

Changes:

- Documentation via rdoc/ri for almost everything. The only real
  exception to this is the Marshal support methods/modules, which you
  don't need to know about except to know that they're there.

- Math types can now be dump/load-ed via Marshal.dump and Marshal.load.
  This should make serialization simpler. Neither of these require that
  you've compiled the library with a particular floating point type,
  though it's a good idea to use Ruby's native type. I should probably
  add something to make Ruby's type the default.

- Add Snow::SNOW_MATH_VERSION constant (a string) to identify which
  version of the gem is installed.

- Preprocessor-generated code is mostly stripped from the bindings in
  order to give rdoc an easier time trying to parse the source (since
  prior to that it just didn't parse it at all).

- Array caches are now implemented via the C bindings rather than the
  cache support module previously included in the gem.

- Added notes on thread safety to the README, just in case anyone was
  doing that, since I realized I knew where the limitations were but
  that I hadn't documented them.

- Replaced a lot of checks for zero with calls to float_is_zero. This
  all gets inlined using either gcc or clang, so don't worry about it.
  Thanks to @siavashserver for that tip.

- Math types no longer raise an exception when comparing incompatible
  types. They just return false now, which seems accurate enough.

- Undid some changes with support modules so documentation could be
  added. Some minor convenience lost, but oh well, nothing huge.