Addtional docstrings in the differential geometry module.

Doctests were slightly updated. Explicit mention about the effect of different
coordinate system choices was added.
Work on itegral curves in the differential geometry module.

Two new functions were added to the differential geometry module that deal with
integral curves. Tests for these functions are supplied.

Integral curves are inherently represented in coordinate dependent way because
there is no coordinate independent way to present movement from point to point
on a general manifold (i.e. there is no such thing as difference between two
points).

The first function is `intcurve_series`. It produces the series expantion of an
integral curve when given the starting point and the coordinate system in which
it must work.

Specify a starting point and a vector field:
>>> start_point = R2_r.point([x, y])
>>> vector_field = R2_r.d_dx

Calculate the series:
>>> series = intcurve_series(vector_field, t, start_point, n=3)
>>> series[0]
[x]
[y]
>>> series[1]
[t]
[0]
>>> series[2]
[0]
[0]

The second function is `intcurve_diffequ` that works in the same way as the
first one, however it returns a system of differential equations describing the
integral curve.

Specify a starting point and a vector field:
>>> start_point = R2_r.point([1, 0])
>>> vector_field = -R2.y*R2.d_dx + R2.x*R2.d_dy

Get the equation:
>>> equations, init_cond = intcurve_diffequ(vector_field, t, start_point)
>>> equations
[f_1(t) + Derivative(f_0(t), t), -f_0(t) + Derivative(f_1(t), t)]
>>> init_cond
[f_0(0) - 1, f_1(0)]
has() refactoring: extract single pattern base case into ._has()

+ Simplify common case, when the pattern is an ordinary Basic instance.
Move preorder_traversal to sympy.core.basic

This will allow it to be used everywhere, and in particular in the core.
Use preorder_traversal in Basic._has()
Simplify Basic.atoms() and use preorder_traversal()
Use preorder_traversal() in Basic.find()
Use preorder_traversal in Basic.count()

* Extract query preprocessing from Basic.find() into _make_find_query(),
  to allow Basic.count() to use it directly.
Simplify code in Basic._has()

* iterative was always True
* the argument of _ncsplit is always an Add or Mul
Basic._has: remove inner function _match()

* .has() shouldn't support objects with non-Basic args, like
Tuple(sin, cos) (cf. issue 2070).
Simplify inner functions in Basic._has()
Basic.has(): move handling of AssocOps to AssocOp

Instead of hardcoding the matching function inside Basic,
pattern._has_matcher() is now used, thus removing a dependency
of Basic on its subclasses.
Fix (x*y).has(x+y) and similar cases.
preserve ability to test for bool and Function in Tuple
Add Class, Object, and Morphism.

These classes represent the very bowels of the module.  They are
yet in their incipient form, which is sufficient, however, to start
writing the tests.
Write the tests for categories.Object and categories.Morphism.

The tests do not pass at the moment.  The goal is to define the desired
behaviour of the methods in Morphism by means of tests.
Implement composing and flattening morphisms.

Composing two morphisms results in a morphism which knows which
morphisms it was composed from.  Flattening such a morphism results in
forgetting the information about components.
Extend the string printer to print Object and Morphism.

Also add the corresponding tests.
When composing morphisms, intersperse morphism names with '*'.

The initial approach to use spaces to separate morphisms names proved
inconsistent with the later idea to use '*' when printing morphism
composition.
Amend the string representation of composition of morphisms.

The initial version did not comply with the requirement that the
represented object be able to be reconstructed from the string
representation.