Enable anonymous downloads on the host and harden Strings.fmt

Host (applied with root@192.168.88.30)
- [service] REQUIRE_SIGNIN_VIEW = false in /etc/gitea/app.ini (backup written
  alongside), Gitea restarted. Verified anonymously: repo page 200, API 200, and a
  release asset downloads at full size (50.8 MB AppImage).

Localization safety (Open Polish)
- Strings.placeholder_count() counts conversions and ignores %% escapes.
- Strings.fmt() validates the count and fails safe (warns, returns the template)
  instead of raising an engine error when a key's placeholders drift.
- Strings.validate() lints the table for a trailing %, unsupported conversions, and
  mixed positional/sequential placeholders.
- Tests cover the counter, the fail-safe path, a clean table, and a formatting pass
  over every placeholder key with type-correct arguments.

Docs
- TODO: distribution, release-pipeline, and open-polish sections are complete and
  moved to DONE; the v0.2.4-v0.2.8 backfill is closed as superseded.
- README/MEMORY updated. Version 0.2.14.

src/core/strings.gd

@@ -34,12 +34,69 @@ static func lookup(key: String) -> String:
 	_ensure_loaded()
 	return TABLE.get(key, key)
 
+## Number of `%` conversion placeholders in a template, ignoring `%%` escapes.
+static func placeholder_count(template: String) -> int:
+	var count := 0
+	var i := 0
+	while i < template.length():
+		if template[i] == "%":
+			if i + 1 < template.length() and template[i + 1] == "%":
+				i += 2
+				continue
+			count += 1
+		i += 1
+	return count
+
 ## Format a string by key with positional arguments.
+##
+## GDScript's `%` binds arguments by order, so a key whose placeholder count drifts
+## from its call site would push an engine error. Validate first and fail safe: log
+## a warning and return the raw template instead of crashing.
 static func fmt(key: String, args: Array) -> String:
 	var template := lookup(key)
 	if template == key:
 		return template
+	var needed := placeholder_count(template)
+	if needed != args.size():
+		push_warning("Strings.fmt(%s): template needs %d args, got %d" % [key, needed, args.size()])
+		return template
 	return template % args
 
+## Lint the loaded table for formatting hazards. Returns an array of problems.
+## Checks: trailing `%`, invalid conversions, and mixed positional (`%1$s`) and
+## sequential placeholders in one template.
+static func validate() -> Array[String]:
+	_ensure_loaded()
+	var problems: Array[String] = []
+	for key in TABLE.keys():
+		var template := str(TABLE[key])
+		var positional := template.contains("$")
+		var sequential := 0
+		var i := 0
+		while i < template.length():
+			if template[i] != "%":
+				i += 1
+				continue
+			if i + 1 >= template.length():
+				problems.append("%s: trailing %% escape" % key)
+				break
+			var next := template[i + 1]
+			if next == "%":
+				i += 2
+				continue
+			var j := i + 1
+			while j < template.length() and template[j] in "0123456789.$":
+				if template[j] == "$":
+					positional = true
+				j += 1
+			if j >= template.length() or not (template[j] in "sdfxXv"):
+				problems.append("%s: unsupported conversion near '%%%s'" % [key, template.substr(i + 1, 3)])
+			elif not positional:
+				sequential += 1
+			i = j + 1
+		if positional and sequential > 0:
+			problems.append("%s: mixes positional (%%1$s) and sequential (%%s) placeholders" % key)
+	return problems
+
 func _init() -> void:
 	push_error("Strings is a static utility class; use Strings.lookup / Strings.fmt.")

src/test/tests/test_strings.gd

@@ -23,6 +23,70 @@ func test_strings_json_backed_all_resolve() -> bool:
 			return TestUtils.fail("key %s resolves to itself — table entry missing" % key)
 	return true
 
+func test_placeholder_count() -> bool:
+	var a := TestUtils.check_eq(Strings.placeholder_count("no args"), 0, "plain text has no placeholders")
+	var b := TestUtils.check_eq(Strings.placeholder_count("%s complies"), 1, "one %s")
+	var c := TestUtils.check_eq(Strings.placeholder_count("%s: \"%s\""), 2, "two %s")
+	var d := TestUtils.check_eq(Strings.placeholder_count("100%% sure"), 0, "%% is an escape, not an argument")
+	var e := TestUtils.check_eq(Strings.placeholder_count("%.0f%% mood"), 1, "float plus percent sign")
+	return a and b and c and d and e
+
+func test_fmt_fails_safe_on_arg_mismatch() -> bool:
+	## A drifting placeholder count must not raise an engine error at runtime.
+	var result: String = Strings.fmt("react.comply", [])
+	var a := TestUtils.check_eq(result, Strings.lookup("react.comply"), "wrong arg count returns the raw template")
+	var extra: String = Strings.fmt("react.comply", ["A", "B"])
+	var b := TestUtils.check_eq(extra, Strings.lookup("react.comply"), "too many args also fails safe")
+	return a and b
+
+func test_table_validates_cleanly() -> bool:
+	var problems: Array = Strings.validate()
+	if not problems.is_empty():
+		return TestUtils.fail("string table format problems: %s" % str(problems))
+	return true
+
+func test_every_placeholder_key_formats() -> bool:
+	## Feed each template one dummy arg per placeholder, with a type that matches
+	## the conversion (%s text, %d int, %f float). Nothing may be left unformatted.
+	var problems: Array[String] = []
+	for key in Strings.TABLE.keys():
+		var template: String = str(Strings.TABLE[key])
+		var specs: Array[String] = _specifiers(template)
+		if specs.is_empty():
+			continue
+		var args := []
+		for spec in specs:
+			var conv: String = spec.substr(spec.length() - 1)
+			if conv == "d" or conv == "x" or conv == "X":
+				args.append(7)
+			elif conv == "f":
+				args.append(1.5)
+			else:
+				args.append("x")
+		var out: String = Strings.fmt(key, args)
+		if out == template:
+			problems.append("%s did not format (%s)" % [key, str(specs)])
+	return TestUtils.check(problems.is_empty(), "all placeholder keys format (problems: %s)" % str(problems))
+
+func _specifiers(template: String) -> Array[String]:
+	var out: Array[String] = []
+	var i := 0
+	while i < template.length():
+		if template[i] != "%":
+			i += 1
+			continue
+		if i + 1 < template.length() and template[i + 1] == "%":
+			i += 2
+			continue
+		var j := i + 1
+		while j < template.length() and template[j] in "0123456789.$":
+			j += 1
+		if j < template.length():
+			out.append(template.substr(i, j - i + 1))
+			j += 1
+		i = j
+	return out
+
 func test_strings_cover_ui_keys() -> bool:
 	## Every key referenced by the HUD and game manager must exist.
 	var required := [