Add municipality and coordinate search, and a map target selector

Puts the controls that change what the map is looking at over the map itself,
where they act, and gives them something to search.

Search is one field, not two. A string either parses as coordinates or it does
not, and the answer is obvious from the text, so making the user declare up
front which kind of thing they are looking for would be asking them to do the
program's job. Coordinates accept decimal and degrees-minutes-seconds, comma or
space separated, with hemisphere letters — including the Italian O for ovest,
because someone reading an Italian map will type it and silently reading it as
east would put them the wrong side of Greenwich.

The 1180 Piedmont municipalities are bundled rather than geocoded online. The
app is region-scoped, so a list of one region's towns is small enough to ship
(100 KB) and beats a geocoder on every axis that matters: instant, offline, no
API key, no rate limit, and it cannot return a result somewhere the app has no
radar for. Matching folds accents, so "aglie" finds "Agliè", and prefix matches
outrank substring ones — typing "tor" should surface Torino, not the first
alphabetical name that happens to contain those letters.

tool/generate_places.py derives the list from Istat boundary shapefiles
(CC BY 4.0). Two properties of that file cost time and are now written down:
the geometry is UTM 32N rather than degrees, and the DBF is UTF-8 despite one
bilingual Friulian record that makes strict cp1252 fail. A terminal renders
utf-8 and latin-1 output identically, so the encoding cannot be settled by
looking at printed text — it took dumping codepoints. A guard in the generator
and a test against the shipped asset both check for mojibake now, and the guard
caught a real mistake the moment it was written.

The target selector switches between following the device, a saved place, and
the whole region, and the selection doubles as what the app reopens on: "the
place I marked" and "what I see when I open the app" are one idea to the person
using it. Dragging the map while it is following stops the camera chasing them
but leaves that preference alone, because looking somewhere else now is not the
same as changing their mind about next launch.

The position marker and the following are MapLibre's own, driven by
onCameraTrackingDismissed, so there is no second location stream to keep in step
with the map.

A test asserts that all 1180 municipalities fall inside the region bounds, which
is what actually validates the UTM-to-degrees conversion end to end.

Verified on the emulator: the dropdown lists follow, region and both saved
places; "aglie" finds Agliè; "44.3841 7.5426" offers the coordinate jump and
lands on Cuneo at town-reading zoom; selecting follow moves the map to the
device position with the blue dot on it and changes the recentre button to
match.

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

Nuvolari/app/lib/features/places/map_target.dart

@@ -0,0 +1,186 @@
+import 'dart:async';
+
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+
+import 'saved_place.dart';
+import 'saved_places.dart';
+
+/// What the map is pointed at.
+sealed class MapTarget {
+  const MapTarget();
+
+  /// The value persisted as the preferred target, or null if it is not a
+  /// sensible thing to reopen on.
+  String? get storageValue;
+}
+
+/// Follow the device: the blue dot stays centred until the user pans away.
+class FollowUser extends MapTarget {
+  const FollowUser();
+
+  @override
+  String? get storageValue => 'follow';
+
+  @override
+  bool operator ==(Object other) => other is FollowUser;
+
+  @override
+  int get hashCode => 'follow'.hashCode;
+}
+
+/// Sit on a saved place.
+class PlaceTarget extends MapTarget {
+  const PlaceTarget(this.place);
+
+  final SavedPlace place;
+
+  @override
+  String? get storageValue => 'place:${place.id}';
+
+  @override
+  bool operator ==(Object other) =>
+      other is PlaceTarget && other.place.id == place.id;
+
+  @override
+  int get hashCode => place.id.hashCode;
+}
+
+/// The whole region, and wherever the user has panned to.
+///
+/// Also what following degrades to the moment the user drags the map: the
+/// camera stops chasing them, which is the behaviour every map app has trained
+/// people to expect.
+class FreeTarget extends MapTarget {
+  const FreeTarget();
+
+  @override
+  String? get storageValue => null;
+
+  @override
+  bool operator ==(Object other) => other is FreeTarget;
+
+  @override
+  int get hashCode => 'free'.hashCode;
+}
+
+/// Remembers what the app should open on.
+abstract interface class PreferredTargetStore {
+  Future<String?> load();
+
+  Future<void> save(String? value);
+}
+
+class SharedPreferencesPreferredTargetStore implements PreferredTargetStore {
+  const SharedPreferencesPreferredTargetStore();
+
+  static const String storageKey = 'nuvolari.preferred_target.v1';
+
+  @override
+  Future<String?> load() async =>
+      (await SharedPreferences.getInstance()).getString(storageKey);
+
+  @override
+  Future<void> save(String? value) async {
+    final prefs = await SharedPreferences.getInstance();
+    if (value == null) {
+      await prefs.remove(storageKey);
+    } else {
+      await prefs.setString(storageKey, value);
+    }
+  }
+}
+
+class InMemoryPreferredTargetStore implements PreferredTargetStore {
+  InMemoryPreferredTargetStore([this._value]);
+
+  String? _value;
+
+  @override
+  Future<String?> load() async => _value;
+
+  @override
+  Future<void> save(String? value) async => _value = value;
+}
+
+final preferredTargetStoreProvider = Provider<PreferredTargetStore>(
+  (ref) => const SharedPreferencesPreferredTargetStore(),
+);
+
+/// The map's current target, and the one it will reopen on.
+///
+/// One notion rather than two, because "the place I marked as preferred" and
+/// "what the app shows me when I open it" are the same thing to the person
+/// using it. Selecting from the dropdown sets both.
+class MapTargetController extends Notifier<MapTarget> {
+  @override
+  MapTarget build() {
+    // Places load asynchronously, so the preferred target is resolved once they
+    // arrive rather than guessed now.
+    ref.listen<AsyncValue<List<SavedPlace>>>(savedPlacesProvider, (
+      previous,
+      next,
+    ) {
+      if (previous?.hasValue ?? false) return;
+      final places = next.value;
+      if (places != null) unawaited(_restorePreferred(places));
+    }, fireImmediately: true);
+
+    return const FreeTarget();
+  }
+
+  bool _restored = false;
+
+  Future<void> _restorePreferred(List<SavedPlace> places) async {
+    if (_restored) return;
+    _restored = true;
+
+    final stored = await ref.read(preferredTargetStoreProvider).load();
+    if (stored == null) return;
+
+    if (stored == 'follow') {
+      state = const FollowUser();
+      return;
+    }
+    if (stored.startsWith('place:')) {
+      final id = stored.substring('place:'.length);
+      for (final place in places) {
+        if (place.id == id) {
+          state = PlaceTarget(place);
+          return;
+        }
+      }
+      // The preferred place was deleted. Forget it rather than reopening on
+      // something that no longer exists.
+      await ref.read(preferredTargetStoreProvider).save(null);
+    }
+  }
+
+  /// Selects [target] and remembers it as what to reopen on.
+  Future<void> select(MapTarget target) async {
+    state = target;
+    await ref.read(preferredTargetStoreProvider).save(target.storageValue);
+  }
+
+  /// Drops out of following without changing what the app reopens on.
+  ///
+  /// Called when the user drags the map while it is chasing them: they want to
+  /// look somewhere else *now*, which is not the same as changing their mind
+  /// about what the app should do next launch.
+  void releaseFollow() {
+    if (state is FollowUser) state = const FreeTarget();
+  }
+
+  /// Forgets a place that has been deleted, if it was the target.
+  Future<void> forget(String placeId) async {
+    final current = state;
+    if (current is PlaceTarget && current.place.id == placeId) {
+      state = const FreeTarget();
+      await ref.read(preferredTargetStoreProvider).save(null);
+    }
+  }
+}
+
+final mapTargetProvider = NotifierProvider<MapTargetController, MapTarget>(
+  MapTargetController.new,
+);