Phase 1: accounts and sessions

Implements PLAN.md Phase 1. A client can now register, log in, manage its
devices and set its profile; an operator can create accounts and flip the
runtime switches. There are still no rooms and no real /sync.

userapi: accounts, argon2id passwords in PHC format, devices, access and
refresh tokens stored as SHA-256 hashes, account data and the admin flag.
Its storage interface is storage.UserStore, implemented once in sqlstore
with `?` placeholders; the postgres driver supplies a rebind function and
unique-violation recognition rather than keeping a second copy of thirty
statements. Timestamps in these tables are int64 milliseconds, the unit the
Client-Server API uses on the wire.

Client-Server API: register (user-interactive auth with m.login.dummy and
optional registration tokens), register/available, token validity, login
with m.login.password, logout, logout/all, refresh, account/whoami,
capabilities, devices/* with password-gated deletion, profile/*, global and
per-room account data.

GET /sync is a deliberate placeholder: it answers a valid token with an
empty but well-formed response and refuses a revoked one. Phase 1 has no
rooms, so that is the whole truth, and it is what makes session revocation
observable. Phase 4 replaces it with the syncapi.

Auth middleware resolves a bearer token (header or the legacy query
parameter) to a device and user, answering an expired token with the soft
logout the spec asks for. Rate limiting is a token bucket per endpoint class
keyed on the client address, returning M_LIMIT_EXCEEDED with retry_after_ms.

adminapi v1 under /_warp/admin/v1: admin-only auth via a normal Matrix
token, GET/PUT /federation and /registration driving internal/settings and
reporting a config-pinned switch as a 409, GET/POST /users, GET /stats.

warp create-account [--admin] creates the first account straight in the
database, so a new install with registration off has a way in.

Complement is wired up for the federation=off profile: an image meeting its
contract, an entrypoint that configures Warp entirely from WARP_*
variables, and a runner that builds, clones and executes the target set
(TestRegistration, TestLogin, TestDeviceManagement). It has not been run
yet -- there is no container runtime on the development machine -- so the
three tests' assertions were read from the Complement sources and pinned as
httptest tests instead, and CI gained a job that runs the real thing.

Also fixes a .gitignore bug from Phase 0: the unanchored `warp` pattern,
meant for the built binary, also matched the directory server/cmd/warp and
silently excluded the entire command package from the repository. The
binary patterns are now anchored to the repository root, and cmd/warp is
committed for the first time.

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

server/internal/storage/sqlite/errors_test.go

@@ -0,0 +1,60 @@
+package sqlite
+
+import (
+	"database/sql"
+	"fmt"
+	"path/filepath"
+	"testing"
+)
+
+// TestIsUniqueViolation checks the error recognition against a real SQLite,
+// because it turns on an extended result code the driver does not export as
+// a constant: a version bump that changed it would otherwise turn "that name
+// is taken" into a 500.
+func TestIsUniqueViolation(t *testing.T) {
+	path := filepath.ToSlash(filepath.Join(t.TempDir(), "test.db"))
+	db, err := sql.Open("sqlite", "file:"+path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() { _ = db.Close() })
+
+	if _, err := db.ExecContext(t.Context(),
+		`CREATE TABLE t (pk TEXT PRIMARY KEY, uniq TEXT UNIQUE)`); err != nil {
+		t.Fatal(err)
+	}
+	insert := func(pk, uniq string) error {
+		_, err := db.ExecContext(t.Context(), `INSERT INTO t (pk, uniq) VALUES (?, ?)`, pk, uniq)
+		return err
+	}
+	if err := insert("a", "one"); err != nil {
+		t.Fatal(err)
+	}
+
+	for name, err := range map[string]error{
+		"duplicate primary key": insert("a", "two"),
+		"duplicate unique key":  insert("b", "one"),
+	} {
+		t.Run(name, func(t *testing.T) {
+			if err == nil {
+				t.Fatal("the insert should have failed")
+			}
+			if !isUniqueViolation(err) {
+				t.Errorf("isUniqueViolation(%v) = false, want true", err)
+			}
+		})
+	}
+
+	// Something that is an error but not a constraint failure.
+	_, err = db.ExecContext(t.Context(), `INSERT INTO nonexistent (x) VALUES (1)`)
+	if err == nil {
+		t.Fatal("inserting into a missing table should have failed")
+	}
+	if isUniqueViolation(err) {
+		t.Errorf("isUniqueViolation(%v) = true, want false", err)
+	}
+
+	if isUniqueViolation(nil) || isUniqueViolation(fmt.Errorf("unrelated")) {
+		t.Error("isUniqueViolation accepted something that is not a SQLite error")
+	}
+}