Use Intel TBB's parallel_sort even for nested parallelism.

TBB has a global task scheduler (that's one of the reason TBB is not
linked statically but dyanmically instead). This allows control over all
running threads, enabling us to use nested parallelism and the scheduler
doing all the task allocation itself.

That is, nested parallel execution such as in

    parallel_for(seq, [](const auto& rng){
      parallel_sort(rng);
    });

is no problem at all, as the scheduler still claims control over the
global environment.

Therefore, use `parallel_sort` Range overload where possible.

References:

- https://www.threadingbuildingblocks.org/docs/help/hh_goto.htm#reference/algorithms.htm
- https://www.threadingbuildingblocks.org/docs/help/hh_goto.htm#reference/algorithms/parallel_sort_func.htm
- https://www.threadingbuildingblocks.org/docs/help/hh_goto.htm#reference/task_scheduler.htm
- https://www.threadingbuildingblocks.org/docs/help/hh_goto.htm#reference/task_scheduler/task_scheduler_init_cls.htm
- https://www.threadingbuildingblocks.org/docs/help/hh_goto.htm#tbb_userguide/Initializing_and_Terminating_the_Library.htm

algorithms/route_name_extraction.hpp

@@ -88,12 +88,11 @@ template <class DataFacadeT, class SegmentT> struct ExtractRouteNames
         }
 
         // pick the longest segment for the shortest path.
-        std::sort(shortest_path_segments.begin(), shortest_path_segments.end(), length_comperator);
+        tbb::parallel_sort(shortest_path_segments, length_comperator);
         shortest_segment_1 = shortest_path_segments[0];
         if (!alternative_path_segments.empty())
         {
-            std::sort(alternative_path_segments.begin(), alternative_path_segments.end(),
-                      length_comperator);
+            tbb::parallel_sort(alternative_path_segments, length_comperator);
 
             // also pick the longest segment for the alternative path
             alternative_segment_1 = alternative_path_segments[0];
@@ -102,15 +101,13 @@ template <class DataFacadeT, class SegmentT> struct ExtractRouteNames
         // compute the set difference (for shortest path) depending on names between shortest and
         // alternative
         std::vector<SegmentT> shortest_path_set_difference(shortest_path_segments.size());
-        std::sort(shortest_path_segments.begin(), shortest_path_segments.end(), name_id_comperator);
-        std::sort(alternative_path_segments.begin(), alternative_path_segments.end(),
-                  name_id_comperator);
+        tbb::parallel_sort(shortest_path_segments, name_id_comperator);
+        tbb::parallel_sort(alternative_path_segments, name_id_comperator);
         std::set_difference(shortest_path_segments.begin(), shortest_path_segments.end(),
                             alternative_path_segments.begin(), alternative_path_segments.end(),
                             shortest_path_set_difference.begin(), name_id_comperator);
 
-        std::sort(shortest_path_set_difference.begin(), shortest_path_set_difference.end(),
-                  length_comperator);
+        tbb::parallel_sort(shortest_path_set_difference, length_comperator);
         shortest_segment_2 =
             PickNextLongestSegment(shortest_path_set_difference, shortest_segment_1.name_id);
 
@@ -127,8 +124,7 @@ template <class DataFacadeT, class SegmentT> struct ExtractRouteNames
                             shortest_path_segments.begin(), shortest_path_segments.end(),
                             alternative_path_set_difference.begin(), name_id_comperator);
 
-        std::sort(alternative_path_set_difference.begin(), alternative_path_set_difference.end(),
-                  length_comperator);
+        tbb::parallel_sort(alternative_path_set_difference, length_comperator);
 
         if (!alternative_path_segments.empty())
         {