[Server] Inform client of login/registration rate limit timeout (#7468)

* [Security] Add per-address rate limiting for auth endpoints

Introduce a thread-safe RateLimiter that tracks attempts per key
(IP address) within a sliding time window, and wire it into the
authentication endpoints:

- Login: failed login attempts from an address are counted; once the
  configured maximum is exceeded within the window, further logins
  from that address are rejected with RespTooManyRequests. A
  successful login clears the failed attempts for that address.
- Registration: implement the previously stubbed
  tooManyRegistrationAttempts, limiting how many accounts can be
  created per address per window.
- Forgot-password: throttle both the email-request and the
  email-challenge paths per address.

New [security] settings with defaults:
  max_login_attempts_per_ip=5 / login_attempt_window_seconds=900
  max_registrations_per_ip=2 / registration_window_seconds=3600
  max_forgot_password_requests_per_ip=3 / forgot_password_window_seconds=3600

Adds unit tests for the RateLimiter (window limit, over-limit
blocking, clearing, per-key independence).

Took 3 minutes

* [Server] Fix rate limiter: disable semantics, draining window, bounded keys, pre-work login gate

- recordAttempt()/isBlocked() return false when maxAttempts <= 0 or windowSeconds <= 0, so the documented 'set to 0 to disable' actually disables instead of blocking every address permanently
- Keys at their limit are rejected without recording, so repeated attempts at the attacker's pace cannot keep sliding the window and holding the lockout open; a block now clears once the recorded attempts age out of windowSeconds
- Attempts map is bounded: an opportunistic prune (every 60s) erases keys whose attempts have fully aged out
- Login is throttled before the work: isLoginRateLimited() (a new virtual on Server, backed by isBlocked()) gates loginUser(), so a locked-out address no longer burns a database round trip and password verification per attempt
- recordAttemptAt()/isBlockedAt() time seams make the sliding-window behaviour deterministically testable; tests rewritten for the real semantics (no reliance on the maxAttempts=0 bug, no sleeps)

* [Server] Inform client of login/registration rate limit timeout

- Add retryAfterSeconds/retryAfterSecondsAt to RateLimiter to compute
  seconds until oldest attempt exits the sliding window
- Expose loginRateLimitRemainingSeconds via Server/Servatrice
- Include denied_end_time (absolute epoch) in RespTooManyRequests for
  login pre-auth and when transitioning to lockout after failed attempt
- Include denied_end_time in registration rate limit response
- Client: show retry time for login RespTooManyRequests
- Client: simplify registration RespTooManyRequests message to show
  retry time when provided
- Add test for retryAfterSecondsAt

* [Client] Restore registration guidance and drop duplicated rate limit reason

The registration RespTooManyRequests case now only shows the retry-after
copy when the server actually sent a denied_end_time; the per-email account
cap path (no end time) falls back to the previous guidance about already
having an account and contacting the server operator.

Drop the canned denied_reason_str from the new login rate limit branches so
the client no longer prints the same sentence twice.

* [Server] Exempt trusted_sources from auth rate limits

Addresses in security/trusted_sources bypass per-address limits, matching
the existing max_users_per_address bypass in initSession. Without this,
Webatrice behind local nginx (all clients as 127.0.0.1) would lock out
every web user after 5 mistyped passwords, and cap the whole server at
2 registrations / 3 forgot-password requests per window.

Adds Servatrice::isRateLimitExempt helper; recordFailedLogin,
isLoginRateLimited, recordRegistrationAttempt and
recordForgotPasswordAttempt all check it.

# Conflicts:
#	servatrice/src/servatrice.cpp

* [Server] Key login rate limit by (address, username)

A successful login cleared the whole per-IP failure history, so 4 bad
guesses plus 1 self-login (or guest UnknownUser login) from the same
address bypassed the limiter. Failures are now bucketed per
(address, lowercase username) and a success clears only its own pair.

---------

Co-authored-by: Lukas Brübach <Bruebach.Lukas@bdosecurity.de>

cockatrice/src/client/network/connection_controller/remote_connection_controller.cpp

@@ -239,6 +239,17 @@ void ConnectionController::onLoginError(int r,
             break;
         }
 
+        case Response::RespTooManyRequests: {
+            QString bannedStr = endTime ? tr("Too many login attempts. Try again after %1.")
+                                              .arg(QDateTime::fromSecsSinceEpoch(endTime).toString())
+                                        : tr("Too many login attempts. Please try again later.");
+            if (!reasonStr.isEmpty()) {
+                bannedStr.append("\n\n" + reasonStr);
+            }
+            QMessageBox::critical(dialogParent, tr("Error"), bannedStr);
+            break;
+        }
+
         case Response::RespWrongPassword: {
             QMessageBox::critical(dialogParent, tr("Error"),
                                   tr("Incorrect username or password. "
@@ -365,12 +376,15 @@ void ConnectionController::onRegisterError(int r, QString reasonStr, quint32 end
             break;
         }
         case Response::RespTooManyRequests: {
-            QMessageBox::critical(dialogParent, tr("Registration denied"),
-                                  tr("It appears you are attempting to register a new account on this server yet you "
-                                     "already have an account registered with the email provided. This server "
-                                     "restricts the number of accounts a user can register per address. Please "
-                                     "contact the server operator for further assistance or to obtain your "
-                                     "credential information."));
+            QString deniedStr =
+                endTime ? tr("Too many registration attempts. Try again after %1.")
+                              .arg(QDateTime::fromSecsSinceEpoch(endTime).toString())
+                        : tr("It appears you are attempting to register a new account on this server yet you "
+                             "already have an account registered with the email provided. This server "
+                             "restricts the number of accounts a user can register per address. Please "
+                             "contact the server operator for further assistance or to obtain your "
+                             "credential information.");
+            QMessageBox::critical(dialogParent, tr("Registration denied"), deniedStr);
             break;
         }
         case Response::RespPasswordTooShort: {