CompositeFilter fix (read comment below)

I had a problem while using the `CompositeFilter`. While trying to retrieve some objects with `Query.getElements(Factory, Filter)` there is a type check in `QueryVisitor.scan`:

>>````{.java}
	public void scan(CtElement element) {
		if (element == null)
			return;
		if (filter.getType().isAssignableFrom(element.getClass())) { /* Here is the type check */
			if (filter.matches((T) element)) {
				result.add((T) element);
			}
		}
		super.scan(element);
	}
>>````

However, `CompositeFilter.getType()` implementation always return `CtElement`. This means that any element will be analyzed by any filter of the `CompositeFilter`. This can lead to `ClassCastException's`. On the other hand, if such an exception is not raised, there will be trouble anyway because perhaps more elements will match the filters of the `CompositeFilter`.

To tackle these problems, in this commit there is a modification **only** for the cases of Intersection and Union. Before applying each filter of the `CompositeFilter` there is now a new type checking constraint. Basically one method was added in `CompositeFilter`:

>>````{.java}
	private boolean hasMatch(Filter<T> filter, T element) {
		if (filter.getType().isAssignableFrom(element.getClass())) {
			return filter.matches(element); /* Old functionality */
		}
		return false;
	}
>>````

The new functionality is covered in the lines 1, 3 and 4 of this new method.

For this modification four tests were added to `FilterTest` class. Namely these are: `FilterTest.typeFilter`, `FilterTest.compositeFilter1` (here you can see that the intersection is now working correctly), `FilterTest.compositeFilter2` (here you can see that the union is now working correctly) and `FilterTest.compositeFilter3` (here you can see that a `ClassCastException` is not thrown anymore).

To verify that these tests were failing before it suffices to comment the following lines in `CompositeFilter.hasMatch`:

>>````{.java}
	private boolean hasMatch(Filter<T> filter, T element) {
		// if (filter.getType().isAssignableFrom(element.getClass())) {
			return filter.matches(element); /* Old functionality */
		// }
		// return false;
	}
>>````

Finally, I would like to suggest to replace the type checking in `QueryVisitor.scan` for a method `Filter.canApplyTo(CtElement)` and also to have a class hierarchy as follows to get rid of `FilteringOperator` enum type:

>>````
|- CompoundFilter
|    |- CompoundIntersectionFilter
|    |- CompoundUnionFilter
|    |- CompoundSubtractionFilter
>>````