Shortcuts consider routing restrictions on the main road too

Previously shortcuts only considered interior roads, starting from the
border intersection, but we need to zoom out just a little bit more and
consider *how* that traffic got to the intersection.

Now routing additionally includes the `main` roads. In order to count
only distinct internal trips, we filter out any routes that use the
perimeter for anything other than starting/ending the trip.

== Perf

Oooph - much slower! It's still pretty fast overall, but I'm going to see if I
can do anything to speed this up.

shortcuts in bristol_east
                        time:   [1.6526 ms 1.6538 ms 1.6552 ms]
                        change: [+130.08% +131.12% +132.13%] (p = 0.00 < 0.05)
                        Performance has regressed.

shortcuts in bristol_west
                        time:   [6.0927 ms 6.0966 ms 6.1012 ms]
                        change: [+121.70% +122.09% +122.45%] (p = 0.00 < 0.05)
                        Performance has regressed.

shortcuts in strasbourg time:   [2.3067 ms 2.3114 ms 2.3193 ms]
                        change: [+88.807% +89.320% +89.947%] (p = 0.00 < 0.05)
                        Performance has regressed.

Author: michaelkirk

backend/src/neighbourhood.rs

@@ -261,6 +261,7 @@ impl Neighbourhood {
                 self.neighbourhood
                     .interior_roads
                     .iter()
+                    .chain(self.neighbourhood.main_roads.iter())
                     .map(|r| self.map.get_r(*r))
             }
 

backend/src/shortcuts.rs

@@ -1,11 +1,10 @@
 use std::collections::HashMap;
 
-use geo::{Euclidean, Length, LineString};
-use geojson::Feature;
-
 use crate::map_model::Direction;
 use crate::route::Router;
 use crate::{MapModel, Neighbourhood, RoadID};
+use geo::{Euclidean, Length, LineString};
+use geojson::Feature;
 
 pub struct Shortcuts {
     pub paths: Vec<Path>,
@@ -27,25 +26,57 @@ impl Shortcuts {
         for start_i in &neighbourhood.border_intersections {
             let start_intersection = map.get_i(*start_i);
             for start_r in &start_intersection.roads {
-                // It's not a "shortcut" unless it cuts through the interior.
-                if !neighbourhood.interior_roads.contains(start_r) {
+                // It's not a "shortcut" unless it starts outside the interior and cuts through the interior.
+                if !neighbourhood.main_roads.contains(start_r) {
                     continue;
                 }
                 for end_i in &neighbourhood.border_intersections {
                     if start_i == end_i {
                         continue;
                     }
                     let end_intersection = map.get_i(*end_i);
-                    for end_r in &end_intersection.roads {
-                        // It's not a "shortcut" unless it cuts through the interior.
-                        if !neighbourhood.interior_roads.contains(end_r) {
+                    'next_road: for end_r in &end_intersection.roads {
+                        // It's not a "shortcut" unless it ends outside the interior after cutting through.
+                        if !neighbourhood.main_roads.contains(end_r) {
                             continue;
                         }
+
                         let Some(route) = router.route_from_roads(*start_r, *end_r) else {
                             continue;
                         };
+
                         let mut shortcut_length = 0.0;
-                        for (r, _direction) in &route.steps {
+
+                        let interior_steps = {
+                            let mut steps = route.steps.iter();
+                            let first_step = steps.next().expect("route can't be empty");
+                            let first_road = map.get_r(first_step.0);
+                            shortcut_length += Euclidean.length(&first_road.linestring);
+                            let mut steps_reversed = steps.rev();
+                            let Some(final_step) = steps_reversed.next() else {
+                                continue;
+                            };
+                            let final_road = map.get_r(final_step.0);
+                            shortcut_length += Euclidean.length(&final_road.linestring);
+
+                            // re-reverse back to the original ordering, but without first and final steps
+                            steps_reversed.rev()
+                        };
+
+                        for (r, _direction) in interior_steps {
+                            // For the purpose of counting unique shortcuts, only the first and
+                            // final steps should be on main roads.
+                            //
+                            // If we've left the interior, only the portion inside the interior counts
+                            // as distinct plausible shortcut.
+                            //
+                            // If a route leaves and re-enters the interior through another border
+                            // intersection, then that route will be counted as two distinct
+                            // shortcuts.
+                            if neighbourhood.main_roads.contains(&r) {
+                                break 'next_road;
+                            }
+
                             let road = map.get_r(*r);
                             *count_per_road.entry(road.id).or_insert(0) += 1;
                             shortcut_length += Euclidean.length(&road.linestring);