Fix indentation on Mat[34]#to_s output.
Version 1.2.5

Fixed to_s output for matrices.
Move back to support modules for inspect.

I don't particularly like doing this because it means a bunch of lines
that essentially do the same thing multiple times for differently-named
classes, but it's the only easy way to provide documentation. Turns out
rdoc/yard are both very, very bad at handling documentation if it's not
inline with the source code. So, back to the slightly less convenient
modules for the sake of generating documentation.
Update ptr.rb with documentation.
Documentation for SwizzleSupport module.
Documentation for ArraySupport module.
Fix equals functions for math types.

Now simply returns false if the types aren't compatible. Raising an
exception seems a little like overkill for equivalency tests.
Kill off a lot of macro usage and update the bindings a bit.

So, notable changes:

- Documentation! Because the preprocessor bits are mostly gone. At least
  there's docs in the C bindings. The Ruby side of things still needs to
  be documented.

- Array types no longer depends on array_cache.rb to cache their fetched
  data wrappers and checks for the existence and so on in the C
  bindings. This might be faster than the Ruby bindings, but the main
  up-shot is that this removes a hack that I layered on top of the typed
  arrays.

- dup and clone are now just aliases of copy. The default dup/clone
  behaviour isn't beneficial for any of the math types and could lead
  very severe problems, so I consider this necessary. This means that
  initalize_copy will never be called by any math type subclass.

These are all more or less motivated by the desire to get some manner of
inline documentation for the source without resorting to really weird
hacks. Or weirder hacks. The fact that #set is also #initialize is bound
to make at least a few people cringe, but it works. In reality, I could
probably break that off into two functions wherein init calls set.
That's low-priority for now, though.
Remove quicky-docs from README because they're no longer needed.
Add extension to gemspec and set markup to markdown.

I feel like there should be breakdancing in here.
Document classes.
Replace zero-checks with float_is_zero.

Assuming a smart compiler will inline these -- clang and gcc will (check
the assembly), though I can't guarantee anything for other compilers.
Remove unneeded class tests in bindings.

These were only really useful when using preprocessor-generated
functions since I wanted subclassing to work (rather than just returning
a new object of the base class type every time). Should still work. The
rule for this is fairly simple:

For binary ops where both lhs and rhs are the same, the output type is
lhs's type (the receiver's type). For binary ops where rhs and output
are the same, the output type is rhs's type unless output is provided,
in which case it's just writing to the output object.

For unary ops where the receiver's type is the same as the output type,
it's always the receiver's type. Otherwise, it's always the output base
class or simply written to output. Subclasses may need to override unary
ops if they want the output to be of a different type, possibly by doing
something like

  def unary_op(output = nil)
    super(output || NewOutputType.new)
  end

which is fundamentally the same thing that the bindings already do, only
it's moving the allocation elsewhere. Just make sure the base class of
the new output type is compatible with the original output type. So,
if output needs to be a Mat3, subclasses must inherit from Mat3 at some
point in their inheritance chain.
Document Mat3 methods.
Add support for Marshal via _dump/_load.

Array support is currently hacked in since Marshal.dump appears to
traverse instance variables, which means dumping an element of an array
creates a circular reference because of how wrapped objects are set up
to prevent their parent memory from being garbage-collected while still
in use.

So, for now, it just duplicates the elements on _dump.
Update notes on outputs.

This is mostly to clear up the stuff about array caching, or at least
remove outdated info.
Add notes on thread-safety to the README.

In general, this is probably specific to my use case, but the point I'm
trying to get across is that none of this is designed with threads in
mind. That rhymes. Not intentional. So I just want to make it clear
what is and isn't safe, and it definitely isn't safe to modify the same
object from multiple threads at the same time. Or even really sane to
modify something from multiple threads.

Messaging is your friend. ZeroMQ included as a recommendation, though
not as something you must specifically use either.
Doc comment for Snow module, even if it's too broad.
Mark marshal support modules with :nodoc: all.

There's really nothing to say about them, so just mark 'em as such.
Add Snow::SNOW_MATH_VERSION constant.

Makes it easier to check at runtime, if needed. Only really useful for
debugging, though.