Re-factoring of bg::distance

In this PR I do a major re-factoring of the `boost::geometry::distance` code. The motivation for doing this re-factoring is due to the following reasons:
* A lot of code can be unified due to the introduction of the segment iterator
* The code is re-designed to first compute the closest features between two geometries and then compute the distance as the distance of the closest feature. A consequence of this is that there is already code that can serve for future implementations of DB GIS functionalities like `ST_ClosestPair` and `ST_ShortestLine`. The other reason is that changes in boost 1.56 broke functionality related to distances in spherical/geographical coordinate system; with this re-factoring this functionality should be available again.

As part of this re-factoring, a few optimizations where made:
* On the code side, the dispatching mechanism is now more compact (because of the use of the segment iterator it is possible to write general algorithms applicable to multiple geometries at the same time)
* On the efficiency side, the R-Tree is now used with segments as objects (for linear and areal geometries), instead of points. For linear geometries this completely avoids the previously existing call to `bg::intersects`. Also there is only one R-Tree now instead of two in the previous version.
* Also on the efficiency side, the point-to-ring algorithm was optimized: previously when calling the relevant static apply method, both (1) the containment of the point in the geometry and (2) the distance of the point to the boundary were computed. In the new version, the containment of the point is computed first, and if needed, its distance to the boundary. So the new version should be faster for points inside the ring.
* The point-to-polygon distance computation is also optimized. In the previous version both the containment of the point in the polygon and the distance to its boundary were always computed (with the latter meaning that the distance of the point to the boundary of all rings of the polygon was computed). In the new version, the point is tested for containment in the exterior ring. If it is not contained inside, the distance of the point to the exterior ring is computed. For points inside, the point is tested for containment in each of the inner rings (holes). If such a hole is found, the distance to this hole's boundary is returned, without further consideration of other holes. If no such hole is found, the point is inside the polygon and 0 distance is returned.
Can you give a concrete example: a point and a polygon?

I have considered the following program:
```
#include <cassert>

#include <iostream>

#include <boost/geometry.hpp>
#include <boost/geometry/geometries/geometries.hpp>

namespace bg = boost::geometry;

typedef bg::model::point<double, 2, bg::cs::cartesian> point_type;
typedef bg::model::ring<point_type, true> cw_ring_type;
typedef bg::model::ring<point_type, false> ccw_ring_type;
typedef bg::model::polygon<point_type, true> cw_polygon_type;
typedef bg::model::polygon<point_type, false> ccw_polygon_type;


int main()
{
    cw_ring_type cw_ring;
    bg::read_wkt("POLYGON((0 0,0 10,10 10,10 0,0 0))", cw_ring);
    assert( bg::is_valid(cw_ring) );

    ccw_ring_type ccw_ring;
    bg::read_wkt("POLYGON((0 0,10 1,10 10,0 10,0 0))", ccw_ring);
    assert( bg::is_valid(ccw_ring) );

    point_type p;
    bg::read_wkt("POINT(1 1)", p);

    std::cout << std::boolalpha;

    std::cout << "CW ring: " << bg::wkt(cw_ring) << std::endl;
    std::cout << "point  : " << bg::wkt(p) << std::endl;
    std::cout << "within : " << bg::within(p, cw_ring) << std::endl;

    std::cout << std::endl;

    std::cout << "CCW ring: " << bg::wkt(ccw_ring) << std::endl;
    std::cout << "point  : " << bg::wkt(p) << std::endl;
    std::cout << "within : " << bg::within(p, ccw_ring) << std::endl;

    std::cout << std::endl;
    std::cout << std::endl;
    std::cout << std::endl;

    cw_polygon_type cw_polygon;
    bg::read_wkt("POLYGON((0 0,0 10,10 10,10 0,0 0),(1 1,9 1,9 9,1 9,1 1))", cw_polygon);
    assert( bg::is_valid(cw_polygon) );

    ccw_polygon_type ccw_polygon;
    bg::read_wkt("POLYGON((0 0,10 1,10 10,0 10,0 0),(1 1,1 9,9 9,9 1,1 1))", ccw_polygon);
    assert( bg::is_valid(ccw_polygon) );

    bg::read_wkt("POINT(5 5)", p);

    std::cout << std::boolalpha;

    std::cout << "CW polygon: " << bg::wkt(cw_polygon) << std::endl;
    std::cout << "point  : " << bg::wkt(p) << std::endl;
    std::cout << "within (polygon) : "
              << bg::within(p, cw_polygon)
              << std::endl;
    std::cout << "within (hole) : "
              << bg::within(p, bg::interior_rings(cw_polygon)[0])
              << std::endl;

    std::cout << std::endl;

    std::cout << "CCW polygon: " << bg::wkt(ccw_polygon) << std::endl;
    std::cout << "point  : " << bg::wkt(p) << std::endl;
    std::cout << "within (polygon): "
              << bg::within(p, ccw_polygon)
              << std::endl;
    std::cout << "within (hole): "
              << bg::within(p, bg::interior_rings(ccw_polygon)[0])
              << std::endl;

    return 0;
}
```
When I run it I get the following output:
```
CW ring: POLYGON((0 0,0 10,10 10,10 0,0 0))
point  : POINT(1 1)
within : true

CCW ring: POLYGON((0 0,10 1,10 10,0 10,0 0))
point  : POINT(1 1)
within : true



CW polygon: POLYGON((0 0,0 10,10 10,10 0,0 0),(1 1,9 1,9 9,1 9,1 1))
point  : POINT(5 5)
within (polygon) : false
within (hole) : true

CCW polygon: POLYGON((0 0,10 1,10 10,0 10,0 0),(1 1,1 9,9 9,9 1,1 1))
point  : POINT(5 5)
within (polygon): false
within (hole): true
```
which is exactly what I want. So what am I missing? What is the problem you refer to?