Keep the caller's foreign key, timestamp and column values on construction

[vsdudakov]

Four places where a constructed instance quietly disagreed with the row it writes. All four surfaced while porting a large application onto yara-orm, and each one currently needs a shim in application code.

What changes

Before	After
create(parent_id=str(pk)) bound correctly but left the raw str on the instance, so child.parent_id == parent.id was False until re-fetch	ForeignKeyFieldInstance.to_python_value mirrors to_db, and the <name>_id column joins MetaInfo.coerced_fields so __init__ normalises it like every other coerced column
A relation object passed alongside an explicit <name>_id silently replaced that id (relations were applied last, unconditionally)	The explicit id wins — by field name or db-column alias — and a relation object whose pk disagrees is not cached as the prefetched relation, so await obj.<rel> cannot return a row the column does not point at
auto_now_add overwrote a caller-supplied stamp, so backdated fixtures, imports and backfills landed at now()	auto_now_add fills the column only when nothing was set. auto_now still always stamps, and so does a field declaring both
Model was not iterable, so dict(instance) and pair-walking consumers (pydantic from_attributes, serializers, factories) could not take a model directly	Model.__iter__ yields (name, value) for the columns the instance carries, in declaration order — skipping columns absent under only()/defer() and private attributes, then any extras kept under Meta.extra_kwargs = "store"

The relation precedence matters most for factories: a SubFactory declaration is evaluated even when the caller also passes author_id=, so the old order made the explicitly requested id unreachable.

Compatibility

Behavioural changes, all in the direction of honouring what the caller passed:

• A row created with an explicit auto_now_add value keeps it instead of being restamped.
• <relation>=obj together with <relation>_id=x now stores x, not obj.pk. Passing only one of the two is unchanged.
• Model instances are iterable, so code that relied on iter(instance) raising TypeError would change behaviour.

FK columns now go through to_python_value on the create path (a cached lookup of the target pk field); row hydration builds instances through __new__ and its decode plan, so reads are untouched.

Tests

Each behaviour and its counter-case, in tests/test_construction_semantics.py (its own module so it runs on Oracle too — test_model_extras's schema is on the Oracle skip list) and tests/test_fields.py: explicit id wins, mismatched object not cached, relation-only construction unchanged, explicit created_at preserved, unset created_at stamped, auto_now stamped even when supplied, iteration including extras, deferred columns skipped.

Full suite on SQLite + PostgreSQL: 1975 passed, 26 skipped. The test_concurrency.py / test_mt_concurrency.py pool tests are excluded from that run — this box is at its max_connections ceiling and they fail identically on released 1.15.0. ruff check, ruff format --check and ty check are clean.

Docs: relation precedence in the relations guide, the auto_now_add rule in models-and-fields, dict(instance) in the querying guide and the API reference.