Some isl types such as isl_ast_node and isl_schedule_node
represent a collection of subclasses that each have their
own corresponding functions.  In C, the user is responsible
for checking the type of the object before calling
the appropriate functions.

In the C++ or Python bindings, the subclasses can instead
be made available as proper subclasses.
Add support for generating these subclasses from
the function that returns the type of the subclass.
In particular, any function with an __isl_subclass annotation
is treated as such a type function.

The generated code is slightly different for C++ and Python.
Since Python is a dynamically-typed language, each object
returned by a C function can be cast directly to the appropriate
subclass.  For this purpose, a __new__ method is introduced
that constructs a Python object of the subclass that corresponds
to the type of the C object.  The __new__ method is overridden
in the subclasses in order to be able to make regular objects
of these subclasses.
The constructor of the superclass is also extended to accept
objects of the (possibly nested) subclasses in order to support
the general casting that is performed when an object is
not of the expected type.
The type checking of the arguments of a method is not changed
by this commit.  In particular, if the first argument is supposed
to be of a type based subclass, then the type check will only
check that it is of the superclass.  This should be safe,
although an exception will be raised through the C level
argument checking if it is not of the correct subclass.

In the C++ bindings, the (static) type of an object returned by
a superclass method is that of the superclass.  This superclass
has two methods for checking the dynamic type and for downcasting
to this type, in particular

bool super::isa<sub>();
and
sub super::as<sub>();

Both methods can only be used for downcasting to an immediate subclass.
The as() method requires the concrete object to be of the expected type.
It will throw an exception if this is not the case.

An alternative would be to let as() return a special value
such as an invalid object when the concrete object is not of
the expected type.  This would be especially convenient
in combination with a conversion of valid/invalid objects to bool as
it would allow constructs of the form

if (auto filter = node.as<isl::schedule_node_filter>()) {
    /* operations on filter node */
}

However, this would be a break from the rule that the (default)
C++ interface never returns an invalid object and in the checked
interface, it would not allow the user to make a distinction
between a conversion failure (which would not be an exceptional result)
and any other failure (which would be an exceptional result).
It was therefore decided to be conservative for now and
to not extend the meaning of "as" in this way.

The names isa and as have been chosen because they are short and
because they allow for a natural reading in English, as in
"if A isa C" and "B is A as C".

The type of an object returned by a subclass method that modifies
the first argument is assumed to be that of the subclass.
This assumption may not apply
to all functions that could potentially be exported.  Further
changes may therefore be required before these functions
can be exported.

Signed-off-by: Sven Verdoolaege <sven.verdoolaege@gmail.com>