Generic functions not being typed correctly in generalized iteration?

[MaximumADHD]

Hopefully I'm describing this correctly? I'm not familiar with the terminology used for types at an implementation level.
Consider the following script:

--!strict
local Node = {}
Node.__index = Node

export type Node<T> = typeof(setmetatable({} :: {
    Value: T
}, Node))

local allNodes = {} :: { INode }
export type INode = Node<any>

function Node.new<T>(value: T): Node<T>
    local node = setmetatable({
        Value = value
    }, Node)
    
    table.insert(allNodes, node)
    return node
end

function Node.Print(self: INode)
    print(self.Value)
end

function Node.GetAllNodes(): {INode}
    return table.clone(allNodes)
end

return Node

When trying to perform a generalized iteration over Node.GetAllNodes() in another script...

--!strict
local Node = require(script.Parent.Node)

for i, generic in Node.GetAllNodes() do
	generic:Print()
end

...the following type error is emitted:

Type Error: (5,2) Type 'INode' could not be converted into 'INode'
caused by:
  Type 'Node' from 'game.Workspace.Node' could not be converted into 'Node' from 'game.Workspace.Node'
caused by:
  Property 'new' is not compatible.
Type
    '(a) -> Node'
could not be converted into
    '<T>(T) -> Node'; different number of generic type parameters

This issue can be worked around if I use pairs(Node.GetAllNodes()) or next, Node.GetAllNodes() instead. I've been observing this issue for as long as I've been using metatable types, though I never hammered down a direct simple repro until recently.