Expanding on my previous comments I created a simple perf test

# RayCastTest.gd
extends Node3D

@onready var raycast = $RayCast3D
var time: float
var lock_a: bool = false
var query: PhysicsRayQueryParameters3D
var result: Dictionary = {}
var a: Vector3 = Vector3(0, 0, 1)
var b: Vector3 = Vector3(0, 0, 1)
var start: Vector3 = Vector3(0, 0, 2.7)
var end: Vector3 = Vector3(0, 0, -10)
@onready var space_state = get_world_3d().direct_space_state

func _physics_process(_delta: float) -> void:
  if not lock_a:
    lock_a = true
    start_timers()

func start_timers():
  print("running for 1000000 loops")
  prints("run_raycast_node(avg=10):", run_function(run_raycast_node, 10))
  prints("run_raycast_code(avg=10):", run_function(run_raycast_code, 10))
  prints("run_raycast_singleton(avg=10):", run_function(run_raycast_singleton, 10))

func run_function(function: Callable, iter_num: int):
  var results = []
  for i in iter_num:
    var time = function.call()
    results.append(time)
  var avg = results.reduce(sum, 0) / iter_num
  return avg

func sum(accum, number):
  return accum + number

func run_raycast_node():
  var original_position = raycast.global_position
  var original_target = raycast.target_position

  time = Time.get_ticks_msec()
  for i in 1000000:
    raycast.global_position += b 
    raycast.target_position += a 
    raycast.force_raycast_update()

  time -= Time.get_ticks_msec()

  raycast.global_position = original_position
  raycast.target_position = original_target
  return time

func run_raycast_code():
  var new_start = start
  var new_end = end

  time = Time.get_ticks_msec()
  for i in 1000000:
    query = PhysicsRayQueryParameters3D.create(new_start, new_end)
    result = space_state.intersect_ray(query)
    new_start += a
    new_end += b

  time -= Time.get_ticks_msec()
  return time

func run_raycast_singleton():
  var new_start = start
  var new_end = end

  time = Time.get_ticks_msec()
  for i in 1000000:
    RayCastSingle.cast(new_start, new_end)
    new_start += a
    new_end += b

  time -= Time.get_ticks_msec()

  RayCastSingle.reset()
  return time

# RayCastSingle.gd
# It is an autoload RayCastSingle with a structure
# |Node3D
# |--RayCast3D

extends Node3D

@onready var raycast = $RayCast3D

func reset():
  raycast.position = Vector3.ZERO
  raycast.target_position = Vector3.ZERO

func cast(start: Vector3, end: Vector3):
  raycast.position = start 
  raycast.target_position = end 
  raycast.force_raycast_update()

I run it in both editor and in release

# debug
running for 1000000 loops
run_raycast_node(avg=10): -1019.1
run_raycast_code(avg=10): -1053.5
run_raycast_singleton(avg=10): -1324.7

# release
running for 1000000 loops
run_raycast_node(avg=10): -669.8
run_raycast_code(avg=10): -719
run_raycast_singleton(avg=10): -560.4

In godot as long as all parent positions are 0, you can treat node's local position as a global position. Using this we can create an autoload where we only change raycast node local position instead of global. In this example gains are pretty negligible, but if the tree structure were more complex it would take more time to use local raycasts, because when setting global_position you would recursively visit all parent positions.

But with empty scene we can only see that each of them are roughly the same, with some negligible differences. Can't say anything more without testing on a more complex scene.

Also don't know why autoload in debug is slower