Bindgen builds and runs now, but does not produce any bindings yet.

We need to compare on variant contents, not just on variant equality

Bindgen currently assumes that it won't see these types from libclang.

Added some misc CXXBaseSpecifier accessors and fixed visiting CXXBaseSpecifiers

Needed for compatibility with latest Clang

We should return true to continue traversal at invalid nodes. We should also
recurse through Stmt nodes that aren't Exprs, since we don't handle them in
bindgen.

Fixes header_const_tparam_hpp

We weren't returning results for anything but string literals. Fixes
header_constant_evaluate_h

…ntity

Clang uses source ranges which start at the first character of the first token
and end at the first character of the last token, while libclang assumes that
the end of the range has been adjusted to after the last character of the last
token. tokenize is the only place we rely on this, so just adjust it here.

RecursiveASTVisitor doesn't call TraverseDecl for these, it calls
TraverseObjCTypeParamDecl directly, so we need to intercept this at the Visit
function.

We used to build a CompilerInvocation and directly set the preprocessor option
to keep detailed records, but we can just tack on CLI args for the same thing.

…ion <= 9

…stdc++

Before Clang 9 these tests did not emit field offset checks because libclang
didn't expose information in these cases. This is fixed in the new interface
now, so we can expect bindgen to emit these checks with all libclang versions.

Several bugs/limitations that existed with clang 3.9 are now gone.

I can't easily bindgen clang_interface.hpp if it includes C++ headers, but we
don't need clang/basic/Version.h in that header anyway if we move this into
clang_interface_impl.hpp instead.

The libclang visitor will visit children of an implicit decl only if that decl
is the top-level parent passed in `Decl_visitChildren`. Otherwise, we should
skip traversal of implicit decls.

Platforms don't mangle C++ the same, so we should avoid depending on C++
mangling if we're going to embed a bindings file.

We can't pass C++ objects by value from C++ to Rust. QualType has an
interface for converting back and forth to void*, so we can use that
instead.