Wrap where the include goes, whenever it lands

[nz]

First of a stack. Where the include goes now decides how far it reaches, so this PR carries the hooks, the schema seam, and what a base-class include needed. Branches after it are stacked and I will open them one at a time as this merges: nz/optional-has-one → nz/nested-attributes-unwrap → nz/cheap-recursion-guard. nz/idempotent-to-option is independent and can be reviewed whenever.

Wrapping followed the include's position, and only reached one class

included do read the reflections and the columns at include time, which made two things true and neither was intended.

The include's position inside a model mattered. Put it where Rails convention puts a concern — at the top, above the associations — and the result was a half-converted model: nullable columns wrapped, associations not, nothing said so.

class Book < ApplicationRecord
  include Errgonomic::Rails::ActiveRecordOptional   # the conventional spelling

  belongs_to :author, optional: true                # silently not wrapped
end

A class body needed a database. Reading column_names at include time meant a model that included the concern raised ActiveRecord::DatabaseConnectionError on load where the same model without it loaded fine. Any boot that loads models without a reachable database — an asset build, an image build, a schema check — failed on the include.

Both come from the same fix

encrypts was already hooked, because an attribute declared after the include has to be caught when it arrives. belongs_to now works the same way, and the columns are wrapped from load_schema!, which is where ActiveRecord defines its own attribute methods. Wrapping is no longer tied to the include's position, and no longer needs a database while classes load.

Once wrapping lives in per-model hooks, the include reaches wherever it is put, so an application can convert every model at once by putting it on its own base class:

class ApplicationRecord < ActiveRecord::Base
  primary_abstract_class
  include Errgonomic::Rails::ActiveRecordOptional
end

That is opt-in or opt-out as placement rather than configuration — no mode to set, no install step to order against the rest of boot. An application's own base class is the useful target: engine and gem models (ActiveStorage::Blob, PaperTrail::Version) descend straight from ActiveRecord::Base, so they stay out by construction rather than by a namespace list this gem would have to maintain.

Three things had to change to make that include work, each with a test that fails without it:

• An abstract class has no table. The walk up the chain asked one for its columns and raised before any model loaded.
• Exclusions were snapshotted at include time. A base-class include leaves a model no "before" to declare anything in, so exclusions are read when a reader is about to be wrapped, and errgonomic_optional_except also takes back a reader already wrapped.
• A model needs an exit that does not point at an include of its own — errgonomic_optional_off, alongside the existing per-attribute errgonomic_optional_except.

Two knock-ons worth reviewing

encrypts now records an exclusion for a schema that has not loaded yet, rather than only reclaiming a reader that already exists.

A subclass reaches the schema seam on its own, so whichever of parent and child is touched first would wrap the shared columns first. A child that got there first wrapped its parent's readers a second time: Some(Some(x)) for a present value, collapsing back to None for an absent one because None#nil? is true — half of it silent. Wrapping walks the chain from the top down instead. Reproducible on the isolated case as Novel#isbn re-entered itself.

errgonomic_optionals also had to start loading the schema, since it is how a conversion gets checked and it answered with the associations alone until something else happened to touch the model.

Testing

rake — 24 tests, 63 assertions, and 118 doctests, all passing. Rubocop reports the same 7 pre-existing offenses as main; the size cops stop applying to test/, where splitting a case to satisfy one hides the behaviour it names.