Port Errbit from MongoDB to SQLite - #3092

Create a single migration defining all 13 tables for Errbit's data
model. Every table includes a unique `bson_id` column to preserve
MongoDB identity for migration mapping. JSON columns store flexible
payloads (request, notifier, server_environment, cached attributes).
Text columns for unpredictable strings (message, body).

Create `Errbit::*` ActiveRecord models mirroring the Mongoid models.
Models use `Errbit::` table prefix and preserve all Mongoid
associations, validations, and scopes. Includes STI support for
notification services and issue trackers.

Add FactoryBot factories for every SQL model and model specs
covering validations, associations, and scope behavior. Configure
RSpec to load the SQL schema before tests and truncate SQL tables
between examples while keeping Mongoid support for migration specs.

Add `errbit:migrate:*` rake tasks that copy data from MongoDB to
SQLite in dependency order. Each task is idempotent by `bson_id`
and uses batched cursor iteration for memory efficiency. Timestamps
are preserved via `record_timestamps = false`.

Create `Errbit::ErrorReport` that processes incoming notices using
SQL models instead of Mongoid. Uses `find_or_create_by!` for
backtraces with unique fingerprint index. Skips notification
delivery and problem recaching when `Errbit.migrating?` is true.

Port all problem-related interactors to use SQL models:
- ProblemDestroy: uncache notices, destroy problem and errs
- ProblemMerge: merge multiple problems into one
- ProblemRecacher: rebuild cached attributes from notices
- NoticeRefingerprinter: reprocess notices with new fingerprint
- ResolvedProblemClearer / OutdatedProblemClearer: cleanup jobs

Create `Errbit::*` decorators wrapping SQL models for the view layer.
BacktraceLineDecorator handles the most complex view logic with
regex matching for in-app detection, gem detection, and path
normalization. All decorators delegate to the wrapped model.

Port async problem deletion jobs to SQL. `DestroyProblemsByIdJob`
accepts an array of problem IDs and destroys them sequentially.
`DestroyProblemsByAppJob` finds all problems for an app and
destroys them. Both use the SQL `Errbit::ProblemDestroy` interactor.

Add Pundit policies for SQL models: `Errbit::ApplicationPolicy`
(base with `permitted_attributes` abstract method),
`Errbit::AppPolicy` (admin-only CRUD), `Errbit::UserPolicy`
(admin-only index/destroy, self-edit). Update `ApplicationPolicy`
doc comment to reference SQL models.

Create `Errbit::Mailer` with `err_notification` and
`comment_notification` actions. Templates use SQL decorators for
consistent rendering. Copies the original mailer's headers and
notification logic but targets SQL models.

Wire the notifier endpoints (Hoptoad v2 and API v3) to use SQL
models. Update `Errbit::ErrorReport` reference, health controller
to use SQL user, and API v3 notice parser.

Wire API v1 controllers to SQL models: comments, notices, problems,
and stats. Update application controller to use SQL user. Update
routes and specs. The backtrace factory reference in specs was
updated to use the SQL factory.

Wire user-facing controllers to SQL models: registration, profile
editing, deletion, GitHub/Google OAuth callbacks, and unlink
controllers. Update request specs to use SQL factories.

Wire the main problem flows: problems controller (search, filter,
sort, resolve, unresolve, merge, delete), apps controller (problem
listing), comments controller, watchers controller. Update helpers
and view partials. Add request specs for the full problem flows.

Wire site config controller to SQL model. Update specs and
application helper to use SQL models.

Remove the `ProblemsSearcher` concern that provided `selected_problems`
and `err_ids` helpers. These methods are now defined directly in
`AppsController` and `ProblemsController` since the concern was
designed for Mongoid's `Problem.find` behavior. Update apps/show
view to reference the new helper.

Update the app notification service form partial to work with SQL
models. The form handles STI for notification services (Slack,
Webhook, etc.) via `type` attribute. Update request specs.

Remove all legacy Mongoid interactors (problem_destroy, problem_merge,
problem_recacher, notice_refingerprinter, resolved_problem_clearer,
outdated_problem_clearer, user_destroy) and their specs. Remove
legacy jobs (destroy_problems_by_app_job, destroy_problems_by_id_job)
and their specs now that callers use the namespaced SQL implementations.
Update database.rake to reference SQL models.

Update the demo rake task to use SQL factories (`:errbit_app`,
`:errbit_problem`, etc.) and `Errbit::ErrorReport`. This allows
the demo task to work with the SQL runtime.

Update `db/seeds.rb` to use `Errbit::User` instead of `User` for
admin user creation. Update bootstrap rake task to reference SQL
models.

Add `errbit:migrate:verify` task that compares SQL row counts
against MongoDB source data. Verifies embedded relations (watchers,
issue_trackers, notification_services, notice_fingerprinters),
problem state preservation (resolved, notices_count, cached
attributes), and relationship mappings (problem->app, err->problem,
notice->app/err/backtrace, comment->problem/user).

Add `ERRBIT_MIGRATE_STRICT` environment variable that causes the
migration to raise an error when any task records failed rows.
This enables CI operators to fail fast with non-zero exit when
migration data is incomplete.

Add request specs that exercise the full HTML runtime against SQL
models: apps index/show/create/edit/copy/delete, problems index/show,
notice redirect flows. These specs prove that all SQL models are
wired correctly and the view layer renders without errors.

Explicitly set `use_active_record = false` in RSpec config to
prevent accidental SQL queries in Mongoid-only specs. This makes
it clear which specs exercise the SQL runtime vs the Mongo runtime.

Update `bin/docker-entrypoint` to run `errbit:bootstrap` (which
runs `db:migrate` and `db:seed`) on container boot. This ensures
the SQL database is ready before the Rails server starts. Update
bootstrap task to include `prepare_mongo_migration` for Mongo
index creation before migration.

Add three migration tests based on real production data shapes. These
cases prevent import failures caused by nulls, empty values, unusually
large payloads, and values that do not map cleanly to SQL:
- Notices with OGNL/attack payloads in messages (from real dump)
- Large hash distributions in cached problem attributes (1140+ counts)
- Problems with notices_count of 0

Add nine tests covering edge cases found in anonymized production data.
These cases protect imports against missing values, empty values, STI
base records, and unusually large or multiline payloads:
- Base NotificationService (no subclass fields) STI fallback
- Problems with resolved_at timestamps (17 resolved in dump)
- Notices with null environment-name in server_environment
- Backtraces with empty lines
- Large user agent distributions (113 entries max in dump)
- Multi-line error messages (300 chars with newlines)
- Apps with empty bitbucket_repo
- Base NotificationService with notify_at_notices [0]
- server_environment with null app-version

Wrap migration writes in bounded transactions and cache SQL ID mappings
per task to reduce query volume during large imports. Keep failures
visible, reset mappings when dependent data changes, and record the
verified cutover marker only after the full migration and verification
pass complete.

Cover migration failures caused by invalid relationships and unique SQL
collisions. Verify that failed imports can resume safely and that
application startup refuses unverified MongoDB data while allowing a
verified migration to proceed.

Refuse to seed or serve an empty SQL database when legacy MongoDB data is
present without a completed migration and verification marker. Run the
cutover guard during bootstrap so accidental data loss requires an
explicit, verified migration first.

Document persistent storage requirements, SQLite WAL limitations, safe
backup procedures, and the MongoDB-to-SQL upgrade path. Add the SQLite
configuration task and ignore the verified cutover marker in deployments.

Document the persistent storage directory, required container ownership,
SQLite WAL sidecar files, and manual configuration when bootstrap is
bypassed. Ignore local MongoDB dumps so migration artifacts are not added
to the repository.

Update controller, request, and factory references from Mongoid models to
the namespaced ActiveRecord models. Adapt expectations for SQL relations,
private controller helpers, pagination, persistence, and error handling
while preserving the existing controller behavior coverage.