Migrate the FortSym generators to the reworked API (#751)

The generators use FortSym's scoped context instead of an explicit arena,
bind field_can_t members declaratively (one members(...) per quantity
with the field_can_t Hessian packing) and select derivatives as sets:
get_val, get_derivatives and get_derivatives2 are partials(4, 0..2), and
the OpenACC Euler kernel takes the second partials touching r or p_phi.
Each field-derivative kernel is now the guiding-centre statements plus one
k%jet call and one emit. The CUDA spline inputs and the Boozer rates bind
their names instead of substituting symbols, and the Horner leaves use
FortGen derivative sets.

Regenerated against FortSym b9ea95c, every generated source is
byte-identical apart from the recorded FortSym revision.

Author: krystophny

gen/generate_axis_maps.f90

@@ -1,17 +1,15 @@
 program generate_axis_maps
     ! Native q is either normalized flux (R=sqrt(q)) or radius (R=q).
     ! No chart selection or boundary policy belongs in this algebraic kernel.
-    use fortsym_arena, only: arena_t
     use fortsym_expr, only: expr_t, sym, sin, cos, sqrt
     use fortsym_expr, only: operator(+), operator(-), operator(*), &
                             operator(/), operator(**)
     use fortsym_diff, only: diff
     use fortsym_kernel, only: kernel_spec_t, emit_kernel, KERNEL_SUBROUTINE
-    use fortsym_string, only: str, chars, str_t
+    use fortsym_string, only: str, chars, str_t, words
     use fortsym_engine, only: engine_result_t
     use fortsym_engine_symengine, only: symengine_engine_t, make_symengine_engine
     implicit none
-    type(arena_t), target :: arena
     type(symengine_engine_t) :: engine
     type(expr_t) :: q, theta, r2, x, y, qdot, thetadot
     type(expr_t) :: radius, inverse_q, radial_factor
@@ -22,15 +20,14 @@ program generate_axis_maps
 
     output_dir = 'src/generated'
     if (command_argument_count() > 0) call get_command_argument(1, output_dir)
-    call arena%init()
-    engine = make_symengine_engine(arena)
-    q = sym(arena, 'q')
-    theta = sym(arena, 'theta')
-    r2 = sym(arena, 'r2')
-    x = sym(arena, 'x')
-    y = sym(arena, 'y')
-    qdot = sym(arena, 'dq')
-    thetadot = sym(arena, 'dtheta')
+    engine = make_symengine_engine()
+    q = sym('q')
+    theta = sym('theta')
+    r2 = sym('r2')
+    x = sym('x')
+    y = sym('y')
+    qdot = sym('dq')
+    thetadot = sym('dtheta')
     r2 = x*x + y*y
     open (newunit=output_unit, file=trim(output_dir)//'/axis_map_generated.f90', &
           status='replace', action='write', iostat=ios)
@@ -50,19 +47,16 @@ program generate_axis_maps
         end if
         forward(1) = radius*cos(theta)
         forward(2) = radius*sin(theta)
-        call emit('axis_'//mode//'_forward', forward, &
-                  [str('q'), str('theta')], [str('x'), str('y')])
+        call emit('axis_'//mode//'_forward', forward, words('q theta'), words('x y'))
         inverse = [inverse_q]
-        call emit('axis_'//mode//'_inverse', inverse, &
-                  [str('x'), str('y')], [str('q')])
+        call emit('axis_'//mode//'_inverse', inverse, words('x y'), words('q'))
         ! qdot=(dq/dr2)*2*(x*xdot+y*ydot). Angular velocity supplies
         ! the orthogonal component. Derive radial factor from the inverse map.
         radial_factor = 1/(x*diff(inverse_q, x) + y*diff(inverse_q, y))
         pullback(1) = radial_factor*qdot*x - thetadot*y
         pullback(2) = radial_factor*qdot*y + thetadot*x
-        call emit('axis_'//mode//'_velocity', pullback, &
-                  [str('x'), str('y'), str('dq'), str('dtheta')], &
-                  [str('dx'), str('dy')])
+        call emit('axis_'//mode//'_velocity', pullback, words('x y dq dtheta'), &
+                  words('dx dy'))
     end do
     write (output_unit, '(a)') 'end module axis_map_generated'
     close (output_unit)

gen/generate_event_energy.f90

@@ -1,28 +1,25 @@
 program generate_event_energy
-    use fortsym_arena, only: arena_t
     use fortsym_expr, only: expr_t, sym, operator(*), operator(**)
     use fortsym_kernel, only: kernel_spec_t, emit_kernel, KERNEL_SUBROUTINE
-    use fortsym_string, only: str, chars
+    use fortsym_string, only: str, chars, words
     implicit none
-    type(arena_t), target :: arena
     type(expr_t) :: energy, p, roots(1)
     type(kernel_spec_t) :: spec
     character(4096) :: output_dir
     integer :: unit
 
     output_dir = 'src/generated'
     if (command_argument_count() > 0) call get_command_argument(1, output_dir)
-    call arena%init()
-    energy = sym(arena, 'energy_eV')
-    p = sym(arena, 'p')
+    energy = sym('energy_eV')
+    p = sym('p')
     roots = [energy*p**2]
     spec%name = str('event_energy')
     spec%mode = KERNEL_SUBROUTINE
     spec%generator = str('gen/generate_event_energy.f90')
-    spec%args = [str('energy_eV'), str('p')]
+    spec%args = words('energy_eV p')
     spec%outputs = [str('kinetic_energy_eV')]
     open (newunit=unit, file=trim(output_dir)//'/generated_event_energy.f90', &
-        status='replace', action='write')
+          status='replace', action='write')
     write (unit, '(a)') 'module generated_event_energy'
     write (unit, '(a)') 'implicit none'
     write (unit, '(a)') 'contains'