GenericValue: add non-template overload for operator!=

As reported in #113, recent versions of Clang complain about
ambiguous overloads for some comparison operator instantiations,
especially if the deduced template type is a GenericValue.

Add an explicit, non-templated version for now (which is a better
match).

This only solves part of the problem, as comparisons between
  * GenericValue & GenericDocument
  * GenericValue with different SourceAllocator types
will still cause ambiguities.
valuetest: extended value comparison tests

Prepare equalto_operator tests to test comparisons between
 * GenericValue and GenericDocument
 * GenericValue with different SourceAllocator types

Both combinations currently fail due to ambiguities with the
templated operators on several compilers.
improve EN/DISABLEIF macros to support complex templated parameters
meta.h: simplify meta programming helpers

Some (older) compilers have problems with compile-time constants.
This commit simplifies the implementation of the helper classes
in order to improve compiler support, especially be removing the
need of partial template specialisation.

No functional changes.
meta.h: add IsBaseOf meta function

In order to match GenericValue and its derived classes for the
SFINAE-implementation of some of the operators/functions, this
meta-function matches all types equal to or derived from a given
class.  See std::is_base_of<B,D> available in C++11.

Define RAPIDJSON_HAS_CXX_TYPETRAITS to use the C++11 implementation.
GenericValue: use IsBaseOf to support comparisons between Value/Document

This finally fixes #113.
GenericValue: add static assert to catch broken SFINAE

Before applying the simplifications in ed282b814, the SFINAE check for the
GenericValue(bool) constructor has been broken in MSVC 2005. Add a static
assert as a safe-guard against future reappearance of this problem.
Merge pull request #125 from pah/fixes/113

Fix comparison operator ambiguities between Value/Document
GenericValue: accept different allocators for read-only access

Several GenericValue functions take a const-reference to another GenericValue
only.  These functions can safely accept values with a different allocator
type.

The following functions are therefore extended by a SourceAllocator template
parameter in this commit:

 - operator==/!=/[]
 - HasMember, FindMember, RemoveMember
 - StringEqual
GenericValue: add and use IsGenericValue meta function

This commit adds an IsGenericValue meta function to match arbitrary
instantiations of the GenericValue template (or derived classes).

This meta function is used in the SFINAE-checks to avoid matching
the generic APIs (operator=,==,!=; AddMember, PushBack) for instances
of the main template.  This avoids ambiguities with the GenericValue
overloads.
valuetest: always test comparisons with different allocators
GenericValue: add explicit operator!=(const Ch*)

MSVC'2005 needs an explicit overload for operator!=(const Ch*)
after the addition of the IsGenericValue SFINAE restrictions.
valuetest: test member operations with different allocators
valuetest: more testing of MemberCount
unittest.h: simplify AssertException

Some compilers warn about the missing initialisation of the std::exception
base class of the AssertException helper.  The simplest solution is to
inherit from std::logic_error instead, which provides all of the required
functionality already.
GenericValue: add move constructor/move assignment

When C++11 is enabled, several algorithms will fail, if GenericValue is
neither copyable, nor movable.

Cherry-picked from 8005b55.
always include "meta.h", as it is not only used for member iterators
meta.h: disallow direct inclusion
rapidjson.h: add RAPIDJSON_GNUC as GCC version shortcut
detect rvalue reference support (RAPIDJSON_HAS_CXX11_RVALUE_REFS)