Added a generic Vector class and two common specializations for 2D and 3D.
Added unit tests for the new Vector class and its specializations.

Added a generic Array class. Array contains a fixed-size array, whose type and size can be specified as template parameters.
    The Array header contains mixins (in the form of preprocessor macros) that can be used to add array methods (such as operator [], begin, end, etc) to classes containing arrays.
    BoundsN, PointN, and VectorN use the Array mixins, which make use of the "data" member in the respective classes.
Added unit tests for Array.

Points and Vectors are now both based off of a common base class. The base class provides data members, constructors, setters, getters, etc.
Macros are used to automatically inherit / reimplement methods in derived classes as necessary.

Renamed "util/Range.hpp" to "util/Clamp.hpp".

Added a generic Range class.
    Ranges are defined by two iterators, begin and end, and have a set of methods and operators (operator [], begin, end, etc).
    Ranges automatically perform checks for null pointers, bad sizes, and bound inversions, which can be disabled with the usual define switches.
    Ranges are C++ ranges (C++ ranges are types that can be provided to std::begin and std::end), and therefore can be provided
    to any function that accepts a C++ range.
    You can specify the type of the iterator and constant iterator the range uses as template arguments.
    Methods for creating Ranges from existing C++ ranges and a begin / end index are provided in the same file:
        slice( cppRange, begin )
        slice( cppRange, begin, end )

Constructors, setters, and getters from other classes that took a "begin" pointer and a size have been removed.
    They have been replaced by templated constructors, setters, and getters that take c++ ranges.
    Here are a couple of examples illustrating the changes:
    //Initialize a 3D point with the first three values of an array
        Before: Point3i pt( arr, 3 )
        After:  Point3i pt( arr )
    //Initialize a 3D point with a slice of an array
        Before: Point3i pt( arr + 3, 3 )
        After:  Point3i pt( slice( arr, 3, 6 ) )

Use of static_cast< T >( ... ) in copy constructors as suggested by Philpax

Use of size_t instead of int as template parameter for PointN, BoundsN, VectorN, etc.

The 2D and 3D specializations of BoundsN now have (min/max)(X/Y/Z) data members that you can use to refer to bounds on a specific axe.

Renamed OutOfBoundsException to BoundsException.

Added rangeSize( cppRange ) to util/Misc.hpp.

Added BS_TMPL_X and BS_SPEC_X macros to util/Macros.hpp (replace X with a number between 1-5)
    These macros are meant to aid metaprogramming, because the C preprocessor doesn't easily allow commas in macro arguments.
    Examples:
        BS_TMPL_2( typename T, size_t N ) becomes template< T, N >
        BS_SPEC_2( T, 5 ) becomes < T, 5 >

Efforts have been made to make the Unit Tests program more independent of Brimstone:
    * The Brimstone::UnitTests namespace is now just UnitTests
    * Defines have been changed from BS_UT_* to UT_*

Changed Warning Level of Unit Tests project to 4. Fixed some minor issues in the project revealed by doing this.

Rearranged defines in Visual Studio projects so that common defines come first, followed by defines that vary between builds.

Added three switches, BS_CHECK_DIVBYZERO, BS_CHECK_DOMAIN, and BS_UT.
    * BS_CHECK_DIVBYZERO causes various functions in the engine that perform divisions (such as vector.normalize(), fastInvSqrt( x ), VectorN::operator /(...) etc)
      to check ahead of time if a divide by zero will result, and throw a DivideByZero exception if it will.
    * BS_CHECK_DOMAIN causes various mathematics-based functions in the engine (such as fastInvSqrt( x )) to check that the value provided is in the function's domain,
      and throw a DomainException if it isn't.
    * BS_UT, if defined, indicates that we're performing unit tests on the code. This can be used to generate different code if necessary.

The naming scheme of variables used in the unit tests has changed to be more consistent across tests.

Added utilities for unit tests in util.hpp and util.cpp.
    Contains functions such as copyAll, allEqual, allEqualTo, etc.
    These functions make use of std::begin and std::end as suggested by Philpax in an earlier commit.

Miscellaneous formatting changes