How do you return nodes from shortest path A* algorithm?

I wrote this A* Shortest Path algorithm using a Priority Queue which works when I map nodes a certain way, but not when I do it another way. Here is the base code for the algorithm:

My heuristic is the distance from the node to the goal node.

-- Example node = {v = "N0", c = {}}
-- v is the node value, also the name
-- c is the children/neighbors of the node in a table

function aStarSearch(start, goal)
	local queue = {}
	local visited = {}
	
	local function testVisited(node)
		for i,v in pairs(visited) do
			if v == node then
				return true
			end
		end
		
		return false
	end
	
	start.d = 0
	table.insert(queue, start)

	local current = nil
	
    while #queue > 0 do
		current = queue[1]
		table.remove(queue, 1)
		
		if not testVisited(current) then
			table.insert(visited, current)
			
			print(current.v, goal.v)
            if current.v == goal.v then
				table.insert(path, current)
				return path
			end

            local neighbors = current.c
			
			for i,v in pairs(neighbors) do
				if not testVisited(v) then
					local predictedDistance = (parts[v.v].Position - parts[goal.v].Position).magnitude
					local neighborDistance = (parts[current.v].Position - parts[v.v].Position).magnitude
					local totalDistance = (parts[current.v].Position - parts[start.v].Position).magnitude + neighborDistance + predictedDistance
					
					if predictedDistance < totalDistance then
						--print(current.v, v.v)
						if #current.c > 0 then 
							table.insert(path, current)
						end
						table.insert(queue, v)
					end
				end
			end
		end
	end
end	

The current way it get's the shortest path is by adding nodes to a path variable here:

if predictedDistance < totalDistance then
	--print(current.v, v.v)
	if #current.c > 0 then 
		table.insert(path, current)
	end
	table.insert(queue, v)
end

This works for when no node has the same neighbor as any other node, or in visual form, this:

No Loops

I already know the issue with this is that if it takes a wrong path and has to backtrack, it has already added the wrong nodes to the path variable.

This happens 95% of the time when I add loops:

Loops

This is how I map the nodes initially:

for i = 1,10 do
	local newNode = createNode("N"..i, {})
	if i == 1 then
		addChild(findNode(start.v), newNode)
	else
		addChild(findNode(lastNode.v), newNode)
		
		local r = math.random(1,2)
		if r == 1 then
			lastNode = newNode
		end
	end
end

And if I want to add loops I do this:

for i,v in pairs(nodes) do
	local r = math.random(1,4)
	local n = math.random(1,10)
	
	while n == i do
		n = math.random(1,10)
	end
	
	addChild(findNode(v.v), nodes[n])
end

So in short my question is, how do I return the CORRECT path and not include any nodes that perhaps ended in a dead end, or were wrong for another way? Perhaps the way I wrote the algorithm is incorrect, which it very well might be since this is my first A* algorithm, so if you see any weird things I do please point them out.