Move server calls to MusicServerClient and give players stable ids

Server requests move out of Settings into a new MusicServerClient
autoload with one function per endpoint. It sends requests through a
swappable HttpTransport so tests can fake the server, and it frees its
HTTPRequest nodes after use.

Players now have a UUID that never changes. Their position in
Settings.player_array is only used for the Alt+<number> keybinds.
Previously the position doubled as the id, so removing a player made
points and wins land on the wrong player, and could delete another
player's point from a song.

Also fixes:
- format_time showed 59.6 seconds as "00:60"
- searches containing regex characters such as "Q*bert" broke search
- SongObject and PlayerObject were Nodes that were never freed; they
  are now RefCounted
- search matching is split out of the UI code into find_matches()

music_server_client.gd

@@ -0,0 +1,124 @@
+extends Node
+## Client for the MusicServer REST API.
+##
+## Registered as the [code]MusicServerClient[/code] autoload, so every script can call it
+## directly, e.g. [code]MusicServerClient.fetch_song_list(on_done)[/code]. All HTTP traffic
+## goes through [member transport]; tests replace it with a fake to answer requests
+## without a running server.
+
+## Sends the actual HTTP requests. Swap it out in tests.
+var transport: HttpTransport
+
+
+func _ready() -> void:
+    if transport == null:
+        transport = HttpTransport.new(self)
+
+
+## Fetches the songs already in the server playlist, as an Array of
+## [code]{SongNo, Soundtrack, Song}[/code] dictionaries.
+func fetch_song_list(on_done: Callable) -> void:
+    get_json("/music/list", on_done)
+
+
+## Downloads a random song as MP3 bytes. With [param low_played] the server prefers
+## soundtracks that have been played the least.
+func fetch_random_song(low_played: bool, on_done: Callable) -> void:
+    get_bytes("/music/rand/low" if low_played else "/music/rand", on_done)
+
+
+## Adds the most recently fetched random song to the server playlist.
+func add_to_queue(on_done: Callable) -> void:
+    send("/music/addQue", on_done)
+
+
+## Fetches [code]{SongNo, Soundtrack, Song}[/code] for the most recently queued song.
+func fetch_song_info(on_done: Callable) -> void:
+    get_json("/music/info", on_done)
+
+
+## Downloads a song from the server playlist as MP3 bytes.
+func fetch_song(song_no: int, on_done: Callable) -> void:
+    get_bytes("/music?song=" + str(song_no), on_done)
+
+
+## Downloads the sound test song as MP3 bytes.
+func fetch_sound_test_song(on_done: Callable) -> void:
+    get_bytes("/music/soundTest", on_done)
+
+
+## Clears the server playlist.
+func reset_playlist(on_done: Callable) -> void:
+    send("/music/reset", on_done)
+
+
+## Fetches every soundtrack name as an Array of Strings.
+func fetch_all_soundtracks(on_done: Callable) -> void:
+    get_json("/music/all", on_done)
+
+
+## Fetches every soundtrack name, sorted, as an Array of Strings.
+func fetch_all_soundtracks_ordered(on_done: Callable) -> void:
+    get_json("/music/all/order", on_done)
+
+
+## Records in the server statistics that a song has been played.
+func mark_song_played(song_no: int) -> void:
+    send("/music/played?song=" + str(song_no), Callable(), HTTPClient.METHOD_PUT)
+
+
+## Fetches the names of all character images.
+func fetch_character_list(on_done: Callable) -> void:
+    get_json("/characters", on_done)
+
+
+## Downloads a character image as PNG bytes.
+func fetch_character_image(character_name: String, on_done: Callable) -> void:
+    get_bytes("/character?name=" + character_name.uri_encode(), on_done)
+
+
+## Starts syncing the server's soundtrack library with its music folder.
+func start_sync(on_done: Callable) -> void:
+    send("/sync", on_done)
+
+
+## Fetches the sync state: [code]{progress, time_spent}[/code] while running, or the
+## sync result once finished.
+func fetch_sync_progress(on_done: Callable) -> void:
+    get_json("/sync/progress", on_done)
+
+
+## Requests [param path] and calls [param on_done] with the parsed JSON.
+## Nothing is called if the request fails or the body is not valid JSON.
+func get_json(path: String, on_done: Callable) -> void:
+    _request(path, HTTPClient.METHOD_GET, func(body: PackedByteArray) -> void:
+        var json: JSON = JSON.new()
+        if json.parse(body.get_string_from_utf8()) != OK:
+            push_warning("Invalid JSON from %s: %s" % [path, json.get_error_message()])
+            return
+        on_done.call(json.data)
+    )
+
+
+## Requests [param path] and calls [param on_done] with the raw response body.
+func get_bytes(path: String, on_done: Callable) -> void:
+    _request(path, HTTPClient.METHOD_GET, on_done)
+
+
+## Requests [param path] and calls [param on_done] with no arguments when it succeeds.
+## [param on_done] may be an empty Callable when the result does not matter.
+func send(path: String, on_done: Callable, method: int = HTTPClient.METHOD_GET) -> void:
+    _request(path, method, func(_body: PackedByteArray) -> void:
+        if on_done.is_valid():
+            on_done.call()
+    )
+
+
+func _request(path: String, method: int, on_success: Callable) -> void:
+    var url: String = Settings.default_path + path
+    transport.request(url, method, func(response_code: int, body: PackedByteArray) -> void:
+        if response_code != 200:
+            push_warning("Request to %s failed with response code %d" % [url, response_code])
+            return
+        on_success.call(body)
+    )