Make the output of Polygon2D to Bone2D NodePaths more usable. (Not sure if this is technically a bug)

[BunkWire2X8]

Polygon2D NodePaths to their Bone2Ds are weird, and I dunno if it's "intentional" like some kind of internal optimization, but I'd at least like a function that outputs them properly without me having to process them all weird.

Here's an example.

In this Polygon2D, the output for these node paths bones 0-3 and 10-12 are compatible with Skeleton2D.get_node().

00: Hip
01: Hip/Chest
02: Hip/Chest/Head
03: Hip/Chest/Head/Chin
04: Hip/LeftArm
05: Hip/LeftArm/LeftForearm
06: Hip/LeftArm/LeftForearm/LeftHand
07: Hip/RightArm
08: Hip/RightArm/RightForearm
09: Hip/RightArm/RightForearm/RightHand
10: Hip/LeftLeg
11: Hip/LeftLeg/LeftLowerLeg
12: Hip/LeftLeg/LeftLowerLeg/LeftFoot
13: RightLeg
14: RightLeg/RightLowerLeg
15: RightLeg/RightLowerLeg/RightFoot

For reference, here's how they're (properly) stored in the scene tree:

Skeleton2D
    ┖╴Hip
       ┠╴Chest
       ┃  ┠╴Head
       ┃  ┃  ┖╴Chin
       ┃  ┠╴RightArm
       ┃  ┃  ┖╴RightForearm
       ┃  ┃     ┖╴RightHand
       ┃  ┖╴LeftArm
       ┃     ┖╴LeftForearm
       ┃        ┖╴LeftHand
       ┠╴LeftLeg
       ┃  ┖╴LeftLowerLeg
       ┃     ┖╴LeftFoot
       ┖╴RightLeg
          ┖╴RightLowerLeg
             ┖╴RightFoot

Do you see the problem? At strange points, it outputs things like Hip/LeftArm, when it should instead output Hip/Chest/LeftArm. Still though, despite the node paths being stored in such a strange way, these bones still work, so I'm assuming that this might be some kind of optimization, which is why I didn't report it as a bug. Also, despite this, I've been able to at least program a workaround to all of this: In a loop where it iterates through all the bones, do something like this:

# Polygon2D node paths to bones are stored in a very convoluted manner, so this is a workaround.
var original_path = NodePath(bone_name)
var corrected_path = original_path
var path_parts: PackedStringArray

# Apply correction if it exists
if is_corrected:
	path_parts = original_path.get_concatenated_names().split("/")
	path_parts.insert(insert_idx, correction)
	corrected_path = NodePath("/".join(path_parts))

var bone = skeleton.get_node_or_null(corrected_path)

if not bone:
	# If correction failed, try without correction
	bone = skeleton.get_node_or_null(original_path)
	if bone:
		# If original path works, reset correction
		correction = ""
		corrected_path = original_path
		is_corrected = false
	else:
		# If both failed, create new correction
		insert_idx = original_path.get_name_count()-1
		var last_part = last_valid_path.get_name(insert_idx)
		correction = last_part
		path_parts = original_path.get_concatenated_names().split("/")
		path_parts.insert(insert_idx, correction)
		corrected_path = NodePath("/".join(path_parts))
		bone = skeleton.get_node_or_null(corrected_path)
		is_corrected = true

Is this the most optimized, foolproof solution? Probably not, as I'd imagine that bones that are named the same would cause some issues. I might be able to work around this by experimenting more and being able to predict when it should make the mistake (Side note: If someone could send me the source code that interprets these NodePaths in Polygon2D, I'd really appreciate it). Still though, internal optimization or not, I'm a little peeved that I need to do this kind of Bone2D NodePath reinterpretation in the first place. I'd really appreciate a function that gets around this.

"Why not just fetch all the bones from Skeleton2D normally?" Good question, and if I was iterating through these bones for the sake of it, I would gladly scrap the above code and do so. Unfortunately though, I'm trying to get the weights for the Polygon2Ds, and I need to know which bones the weights are relevant to.