DirichletBC using data from other spaces + adjoint + multigrid support

[pbrubeck]

Description

DirichletBC now accepts boundary data as a Function on a different FunctionSpace, not only
composite expressions involving one — e.g. DirichletBC(V1, Function(V2), sub) now works, matching
the composite case (DirichletBC(V1, 2*Function(V2), sub)) that already did.

This is needed so DirichletBCs can be refined symbolically rather than numerically in an adaptively
refined MeshHierarchy (#5213): symbolic and numeric coarsening agree when spaces are nested, but not
under refinement, where numeric coarsening would keep applying the coarse BC throughout the adaptive
loop and accumulate large errors. Since the symbolic boundary data can live on a different space than
the BC itself, BCBase.coefficients() (and EquationBC/EquationBCSplit equivalents) is added so DM
hooks can be attached to every coefficient's own function space and the right TransferManager found.

Differentiability under pyadjoint comes from composition with the taped operations rather than new
adjoint code:

• The internal interpolation of the boundary data onto the BC's space is routed through the annotated
  assemble(), so it is recorded as its own block on the tape; likewise the fallback for elements
  without interpolation support (e.g. HCT) is routed through the now annotated Projector.
• DirichletBCBlock depends on the Function the BC actually applies (the interpolation output),
  not the raw user-supplied value, and the interpolation is re-taped whenever the BC is added as a
  dependency of another block (_ad_will_add_as_dependency), so the dependency always points at the
  current boundary data. The adjoint, TLM, and Hessian then flow through the interpolation's or
  projection's own block, which removed DirichletBCBlock's hand-rolled interpolation pullback and
  its dead constant-handling machinery.
• Reusing a DirichletBC (set_value or in-place mutation of the data in a time loop, with a cached
  NonlinearVariationalSolver) is differentiable too, not just a freshly-constructed BC each step:
  each solve records its own interpolation + BC chain, and NonlinearVariationalSolveBlock resyncs
  its cached solver's BCs per recompute instead of reusing whatever the shared, live BC currently
  holds.

Added regression tests with Taylor tests: the time-dependent cross-space BC parametrized over both
configurations above, and a projected (HCT) boundary value. The AGENTS.md pyadjoint notes are
rewritten as the composition-first design principles that came out of this work.

[connorjward]

Since the symbolic boundary data might live on different function spaces, we need to add BCBase.coefficients() so that we can attach DM hooks to the function spaces of every coefficient in the problem and be able to extract the correct TransferManager of the problem.

Not for this PR but I think that this needs cleaning up. This dmhooks business is getting quite out of hand. I plan on doing this at some point.

This PR also enables prescribing BC data from a different FunctionSpace. Previously we were not allowing the data to be a pure Function on a different space, e.g. DirichletBC(V1, Function(V2), sub), but we allowed composite expressions with Functions on a different space, e.g. DirichletBC(V1, 2*Function(V2), sub). Here we allow both cases.

Seems reasonable. This needs to be written down somewhere though. Both in a docstring and the manual.

[connorjward]

Adjoint test please. Control must be a Function in an expression in a BC.

Then definitely qualifies for release.

[connorjward]

Adjoint test please. Control must be a Function in an expression in a BC.

Then definitely qualifies for release.

[dham]

I think the right approach here is that the "forward_nlvs" should have a copy of the bcs which should depend on copies of any coefficients in the BC expressions, and the coefficient values should be overwritten at this point.

[connorjward]

I had the following question in the meeting:

Consider a solve like:

f = Function(V)
solve(a == f * v * dx, bcs=[DirichletBC(V, f, ...)])

If we copy and replace the function f for the form and bc separately then we will get something like:

solve(a == g * v * dx, bcs=[DirichletBC(V, h, ...)])

Is this something to be concerned about? Is it even legal?

[pbrubeck]

I'll add such case (f in both RHS and BC data, used as Control) as a Taylor test.

[connorjward]

Do we not need to annotate init? I thought that that's the pattern for this sort of thing.