Q:

self referencing generic with inheritence

I have a class AnimalQueue which is a queue of Animals.  Each queue will only store a certain type of Animal, and I want to make sure that only Animals that match the type of the queue are added to it:
Public Class AnimalQueue(Of T As Animal)
    Public Sub Add(pA As T)
    End Sub
End Class

When an Animal in the queue is processed, I want to pass the queue that is processing it to the Animal in case the Animal wants to add another Animal to the same queue:
Public MustInherit Class Animal
    Public MustOverride Sub Process(Of T As Animal)(pAQ As AnimalQueue(Of T))
End Class

The problem is that when I add a concrete class I get a compile error at the call to Add:
Public Class Horse
    Inherits Animal

    Public Overrides Sub Process(Of T As Animal)(pAQ As AnimalQueue(Of T))
        pAQ.Add(New Horse())
    End Sub
End Class

It says Horse can't be converted to T, but the constraint says that T is an Animal and Horse is an Animal...

A:

The problem is that T might be any class that is derived from animal. Assume the following class hierarchy:
Horse -> Animal
Dog -> Animal

In your code, the generic parameter T of Process is constrained to be any animal. So even if you implement it on the Horse class, the following call would be perfectly valid:
Dim dogQ As New AnimalQueue(Of Dog)()
Dim h As New Horse()
h.Process(Of Dog)(dogQ)

In this case, your implementation of Process would try to add a Horse to a queue of Dogs. As Horse is not derived from Dog, you cannot do this.
I assume that you want to create a method so that the Process method of Horse only accepts a queue of Horses and the Process method of Dog only accepts a queue of Dogs. 
There are several ways to accomplish this:

Do not create a generic Process method on the level of the base class, but only Process methods on the level of the children (e.g. for Horse: Public Sub Process(horseQ As AnimalQueue(Of Horse))). 
Use a New constraint and implement the method on the level of Animal. In your comments, you mention that your animals need constructor parameters, so this is not an option.
If you want to have a base class that defines the generic method, you could create the following structure:

Public Class AnimalQueue(Of T As Animal)
    Public Sub Add(animal As T)
        ' ...
    End Sub
End Class

Public MustInherit Class Animal

End Class

Public MustInherit Class ProcessableAnimal(Of T As Animal)
    Inherits Animal

    Public MustOverride Sub Process(q As AnimalQueue(Of T))

End Class

Public Class Horse
    Inherits ProcessableAnimal(Of Horse)

    Public Overrides Sub Process(q As AnimalQueue(Of Horse))
        q.Add(New Horse())
    End Sub
End Class

Public Class Dog
    Inherits ProcessableAnimal(Of Dog)

    Public Overrides Sub Process(q As AnimalQueue(Of Dog))
        q.Add(New Dog())
    End Sub
End Class

In this approach, there is a new level of inheritance. But the significant change is that you set the generic type parameter on class level. So the decision is made when deriving from ProcessableAninmal and is not left to the caller of Process. 
Dim h As New Horse()
Dim hQ As New AnimalQueue(Of Horse)()
Dim dQ As New AnimalQueue(Of Dog)()
h.Process(hQ) ' Valid
h.Process(dQ) ' NOT VALID ANYMORE

