Standardize use of splines in the vacuum module

[jhalpern30]

Making this a subissue to switching to a standardized spline package since there's no use in doing this before.

Right now, our usage of splines is all over the place in the vacuum module. For example:

1. We have the periodic_cubic_deriv function for the dx/z_dtheta splines (in initialize_plasma_surface!)

    # Plasma boundary theta derivative: length mth with θ = [0, 1)
    θ_grid = range(; start=0, length=mtheta, step=2π/mtheta)
    dx_dtheta = periodic_cubic_deriv(θ_grid, x_plasma)
    dz_dtheta = periodic_cubic_deriv(θ_grid, z_plasma)

2. Sometimes, we just call cubic_spline_interpolation directly (in kernel!)

    # Used for Z'_θ and X'_θ in eq.(51)
    spline_x = cubic_spline_interpolation(theta_grid, x_sourcepoints; extrapolation_bc=Interpolations.Periodic())
    spline_z = cubic_spline_interpolation(theta_grid, z_sourcepoints; extrapolation_bc=Interpolations.Periodic())
    dx_dtheta = [Interpolations.gradient(spline_x, t)[1] for t in theta_grid]
    dz_dtheta = [Interpolations.gradient(spline_z, t)[1] for t in theta_grid]

3. Sometimes, we just use cubic_spline_interpolation with no BCs (in interp_to_new_grid)

    # Input grids are from [0, 1] inclusive, since no interpolants will fall outside of this, we don't need periodic extrapolation
    θin = range(0.0, 1.0; length=mtheta_in)
    itp = cubic_spline_interpolation(θin, vecin)

4. And sometimes, we use the hardcoded lagrange1D interpolation (in distribute_to_equal_arc_grid)

        # Calculate dx/dt and dz/dt using Lagrange interpolation (order 3)
        _, d_xin = lagrange1d(theta_in1, xin1, mtheta1, 3, theta, 1)
        _, d_zin = lagrange1d(theta_in1, zin1, mtheta1, 3, theta, 1)

This is super confusing and could definitely be simplified (and can easily mask hidden bugs), considering we're splining the same thing almost every time and in a nearly identical way (a x/z grid over theta that ranges from [0, 2pi). Once we have a standardized spline package, we should go through and ensure a consistent usage of splines

[jhalpern30]

Related to this - I think there is a small bug in the Fortran code when using the equal_arc_wall parameter, or at least should be better checked out. In initialize_wall, we perform a gridded interpolation due to the nonuniform theta grid points

  x_wall, z_wall, _, theta_grid, _ = distribute_to_equal_arc_grid(x_wall, z_wall, mtheta)
  theta_grid .= theta_grid .* (2π)  # Scale to [0, 2π) - irregular spacing
  fx_of_theta = interpolate((theta_grid,), x_wall, Gridded(Linear()))
  dx_dtheta = only.(Interpolations.gradient.(Ref(fx_of_theta), theta_grid))
  fz_of_theta = interpolate((theta_grid,), z_wall, Gridded(Linear()))
  dz_dtheta = only.(Interpolations.gradient.(Ref(fz_of_theta), theta_grid))

However, we never actually use these derivatives later, and spline over the uniform theta grid in the kernel function, so the spline theta and x/z points should disagree I think. We should verify if this is true, and if so, could possibly fix it by passing in the theta_grid to spline over in the geometry structs.

[jhalpern30]

Another issue on this front - I don't think we're using the periodic BCs correctly. For our splines, we're setting extrapolation_bc = Periodic(), however I've done some looking at I think we actually need to be specifying bc = Periodic(). The extrapolation BC just wraps grid points around to the start, which we never do anyway - I think the only time this would happen is in the Gaussian quadrature but we do theta_gauss = mod(theta_gauss0, 2pi anyway. The bc = Periodic() is what affects the derivatives at the endpoints, which we were avoiding.

As a second note, we need to include endpoints in the grids to properly capture the periodic behavior with these BCs. Currently, the grids we spline over do not include the endpoint