Add support for non-Intel architectures by using gcc builtins where
possible, but only on non-Intel builds. This permits builds to continue
to work on Intel architectures even with older gcc versions that do not
have the builtins.

atomic_intrinsics_gcc.h contains non-portable Intel assembly, so move it
to atomic_intrinsics_gcc_intel.h and add an
atomic_intrinsics_gcc_generic.h equivalent that uses only modern gcc
builtins.

Adjust atomic_intrinsics.h to use atomic_intrinsics_gcc_intel.h in the
Intel case, and atomic_instrinsics_gcc_generic.h in an additional
"otherwise" case.

This does not change behaviour or compatibility in the common IA-32 and
x86_64 cases. The previously existing code will continue to be used in
these cases. An older gcc without the modern gcc builtins will continue
to be able to build on these architectures because the previously
existing assembly will be used.

This does make this code fully portable to any architecture supported by
a modern gcc, since the new, generic code will be used in this case.

Detect platforms that define __arm__ and __aarch64__ as 32-bit and
64-bit platforms respectively.

Switch to using gcc atomic builtins for atomic operations if using a new
enough gcc and clang and support is available. Otherwise, fall back to
the old behaviour of existing non-portable inline assembly to continue
to support builds on older versions of gcc.

Since we're using a bool, defaulting to C++ (or otherwise enabling bool)
is mandatory.