Refactor travel segments and simplify trip options

Travel segment architecture:
- Remove departureTime/arrivalTime from TravelSegment (location-based, not date-based)
- Fix travel sections appearing after destination instead of between cities
- Fix missing travel segments when revisiting same city (consecutive grouping)
- Remove unwanted rest day at end of trip

Planning engine fixes:
- All three planners now group only consecutive games at same stadium
- Visiting A → B → A creates 3 stops with proper travel between

UI simplification:
- Remove redundant sort options (mostDriving/leastDriving, mostCities/leastCities)
- Remove unused "Find Other Sports Along Route" toggle (was dead code)

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

SportsTime/Planning/Engine/ScenarioBPlanner.swift

@@ -296,54 +296,82 @@ final class ScenarioBPlanner: ScenarioPlanner {
     // MARK: - Stop Building
 
     /// Converts a list of games into itinerary stops.
-    /// Groups games by stadium, creates one stop per unique stadium.
+    /// Groups consecutive games at the same stadium into one stop.
+    /// Creates separate stops when visiting the same city with other cities in between.
     private func buildStops(
         from games: [Game],
         stadiums: [UUID: Stadium]
     ) -> [ItineraryStop] {
+        guard !games.isEmpty else { return [] }
 
-        // Group games by stadium
-        var stadiumGames: [UUID: [Game]] = [:]
-        for game in games {
-            stadiumGames[game.stadiumId, default: []].append(game)
+        // Sort games chronologically
+        let sortedGames = games.sorted { $0.startTime < $1.startTime }
+
+        // Group consecutive games at the same stadium
+        var stops: [ItineraryStop] = []
+        var currentStadiumId: UUID? = nil
+        var currentGames: [Game] = []
+
+        for game in sortedGames {
+            if game.stadiumId == currentStadiumId {
+                // Same stadium as previous game - add to current group
+                currentGames.append(game)
+            } else {
+                // Different stadium - finalize previous stop (if any) and start new one
+                if let stadiumId = currentStadiumId, !currentGames.isEmpty {
+                    if let stop = createStop(from: currentGames, stadiumId: stadiumId, stadiums: stadiums) {
+                        stops.append(stop)
+                    }
+                }
+                currentStadiumId = game.stadiumId
+                currentGames = [game]
+            }
         }
 
-        // Create stops in chronological order (first game at each stadium)
-        var stops: [ItineraryStop] = []
-        var processedStadiums: Set<UUID> = []
-
-        for game in games {
-            guard !processedStadiums.contains(game.stadiumId) else { continue }
-            processedStadiums.insert(game.stadiumId)
-
-            let gamesAtStadium = stadiumGames[game.stadiumId] ?? [game]
-            let sortedGames = gamesAtStadium.sorted { $0.startTime < $1.startTime }
-
-            let stadium = stadiums[game.stadiumId]
-            let city = stadium?.city ?? "Unknown"
-            let state = stadium?.state ?? ""
-            let coordinate = stadium?.coordinate
-
-            let location = LocationInput(
-                name: city,
-                coordinate: coordinate,
-                address: stadium?.fullAddress
-            )
-
-            let stop = ItineraryStop(
-                city: city,
-                state: state,
-                coordinate: coordinate,
-                games: sortedGames.map { $0.id },
-                arrivalDate: sortedGames.first?.gameDate ?? Date(),
-                departureDate: sortedGames.last?.gameDate ?? Date(),
-                location: location,
-                firstGameStart: sortedGames.first?.startTime
-            )
-            stops.append(stop)
+        // Don't forget the last group
+        if let stadiumId = currentStadiumId, !currentGames.isEmpty {
+            if let stop = createStop(from: currentGames, stadiumId: stadiumId, stadiums: stadiums) {
+                stops.append(stop)
+            }
         }
 
         return stops
     }
 
+    /// Creates an ItineraryStop from a group of games at the same stadium.
+    private func createStop(
+        from games: [Game],
+        stadiumId: UUID,
+        stadiums: [UUID: Stadium]
+    ) -> ItineraryStop? {
+        guard !games.isEmpty else { return nil }
+
+        let sortedGames = games.sorted { $0.startTime < $1.startTime }
+        let stadium = stadiums[stadiumId]
+        let city = stadium?.city ?? "Unknown"
+        let state = stadium?.state ?? ""
+        let coordinate = stadium?.coordinate
+
+        let location = LocationInput(
+            name: city,
+            coordinate: coordinate,
+            address: stadium?.fullAddress
+        )
+
+        // departureDate is day AFTER last game (we leave the next morning)
+        let lastGameDate = sortedGames.last?.gameDate ?? Date()
+        let departureDateValue = Calendar.current.date(byAdding: .day, value: 1, to: lastGameDate) ?? lastGameDate
+
+        return ItineraryStop(
+            city: city,
+            state: state,
+            coordinate: coordinate,
+            games: sortedGames.map { $0.id },
+            arrivalDate: sortedGames.first?.gameDate ?? Date(),
+            departureDate: departureDateValue,
+            location: location,
+            firstGameStart: sortedGames.first?.startTime
+        )
+    }
+
 }