improve assigner to use aggregates where possible

[matt-beanland]

requires AshNeo4j 0.5.1 or later. Full benefit with 0.6.0 which optimises diffo-dev/ash_neo4j#253

Currently the Assigner does N queries per pool lookup, plus DefinedSimpleRelationship returns all :assignedTo relationships regardless of thing.

If rewritten to aggregates:

The filter has two conditions:

type == :assignedTo — scalar atom property, straight WHERE d.type = "assignedTo" in Cypher. This is the simplest possible case for #253
.
characteristic.name == thing — JSON-encoded embedded field. Can't be pushed to Cypher regardless, stays Elixir-side.

if we've know assigned then we shouldn't need to do another query for free, we can calculate locally by enumerating the pool and differencing to find free.

[matt-beanland]

We've decided to leave DefinedSimpleRelationship as general primitive of an invariant relationship with up to one characteristic, and to create AssignmentRelationship

Goal: replace the embedded NameValuePrimitive approach for pool assignments with a dedicated resource whose thing and value are top-level scalar attributes, making them filterable at the Cypher level and enabling proper aggregate pushdown via #253.

New file
lib/diffo/provider/components/assignment_relationship.ex — AssignmentRelationship

Fragments BaseRelationship (inherits source/target, type, timestamps)
Attributes: thing :atom, value :integer
Actions: create (accept thing, value, source_id, target_id) + destroy
Jason encoding to match existing assignment output shape
Modified files
assignable_characteristic.ex

Add has_many :assignments, AssignmentRelationship, source_attribute: :instance_id, destination_attribute: :source_id
Add aggregate :assignment_count, :count, :assignments, filter: expr(thing == parent(thing)) — benefits from #253
Replace calculate :free module reference with expr(last - first + 1 - assignment_count) — no Elixir module needed
Keep calculate :assigned_values but update it to use load/3
assigned_values.ex — simplified

load/3 returns [:assignments] — Ash pre-loads, no extra DB call
calculate/3 filters record.assignments by thing in Elixir, maps to .value
free_values.ex — deleted (replaced entirely by expression)

assigner.ex

relate_is_assigned: create AssignmentRelationship directly, drop NameValuePrimitive/Primitive
find_assignment: read_one with scalar filters on thing and value — no Enum.find
pool_characteristic: load [:assignments] directly, remove assigned_values: [thing: thing] load
base_instance.ex — has_many :assignments target updated to AssignmentRelationship

Provider domain — AssignmentRelationship added to resources

AGENTS.md — project structure updated

What this unlocks
type == :assignedTo already handled by relationship scope; thing == parent(thing) aggregate filter goes to Cypher via #253
free is pure data layer arithmetic — no custom calculation module
find_assignment is a clean read_one — no Elixir filtering
AssignedValues fires zero extra DB queries — pre-loaded
DefinedSimpleRelationship is untouched — clean public primitive

[matt-beanland]

The assigner previously stored assignments as DefinedSimpleRelationship records with an embedded NameValuePrimitive characteristic. The embedded value is opaque to the AshNeo4j data layer — it cannot be filtered in Cypher, so all filtering happened in Elixir after loading the full record set.

The fix introduces AssignmentRelationship, a dedicated resource that stores pool, thing, and value as top-level scalar attributes on the Neo4j node. This makes them filterable at the Cypher level, with AshNeo4j #253 pushing thing and source_id filters into the WHERE clause. The FreeValues and AssignedValues calculations now query AssignmentRelationship directly with those filters rather than loading all assignments and filtering in Elixir. The Assigner itself uses the same direct query pattern via a new assigned_values_for/2 helper, removing the previous dependency on a has_many :assignments traversal from the characteristic node (which doesn't exist as a graph edge).

An identity on [:source_id, :pool, :thing, :value] with pre_check? true guards against concurrent duplicate assignments. AshNeo4j doesn't yet push identities to Neo4j unique constraints — that is tracked in ash_neo4j #20, now updated with the concrete use case.

Assignments continue to appear in serviceRelationship or resourceRelationship in the TMF JSON output, routed by the target instance type, via the existing Instance.relationships() merge. Test suite: 648 tests, 0 failures, 8.1s.