Is there a way to ensure a generic type will be a base class of another class in C#?

So here is my problem:

public abstract class Animal
{
    protected List<List<???>> _groups;

    public Animal(List<List<???>> groups)
    {
        _groups = groups;

        foreach (List<???> group in groups)
        {
            group.Add(this);    
        }
    }
}


public abstract class Mammal : Animal
{
    public Mammal(List<List<???>> groups) : base(groups)
    {
    }
}

public class Dog : Mammal
{
    public Dog(List<List<???>> groups) : base(groups)
    {
    }
}

As you can see, I have an Animal abstract class and its subclasses like Mammal. These subclasses will also have their own, possibly concrete subclasses like Dog. The animal class has a _groups field. A group of animals could look like this:

List<Mammal> mammals = new List<Mammal>();

//         or

List<Animal> twoLegsAnimals = new List<Animal>();

When creating an animal you can pass it all the groups it belongs to. The problem (as you can see by the ??? used as generics) is how do you pass the animal the groups so that it can't add itself into a group it does not belong to (eg. a Duck cannot be in the mammals group) AND so that it can add itself into all groups it needs to.

I tried doing something like this:

public class Dog : Mammal
{
    public Dog(List<List<T>> groups) : base(groups) where Dog : T
    {
    }
}

this would logicaly make sense because you can pass the dog only the groups it could be in. The problem is that C# does not allow me to say that Dog has to extend T. Basically T needs to be a base of Dog. Any way to get around this?

EDIT: Ok there is a lot of confusion going on with the "group" concept. By group I just mean a list of animals. For example a Deers and Sheeps could be added to preys group. A Wolf could then have a Hunt(List<Animal> preys) method that would kill a random prey. He would use a Kill method on the prey (available on all animals) that will remove the prey from all the groups it is in. I don't really see any other way to achieve this kind of interaction.

EDIT2: Sorry I figured out what I wrote wrong. Originaly I wrote:

List<List<Mammal>> mammals = new List<List<Mammal>>();

//         or

List<List<Animal>> twoLegsAnimals = new List<List<Animal>>();

I hope "groups" makes more sense now.

You can add a type constraint like this:

public abstract class Animal<T> where T : Animal<T>
{
    protected List<List<T>> _groups;

    public Animal(List<List<T>> groups)
    {
        _groups = groups;

        if (this is T x)
        {
            foreach (List<T> group in groups)
            {
                group.Add(x);
            }
        }
    }
}

then, e.g. the Dog class will be declared as:

public class Dog : Animal<Dog> { … }

As a matter of course, you can't prevent the user passing in e.g. a Fish : Animal<Fish> into Dog. What you could do, is a runtime check in the constructor:

public Animal(List<List<T>> groups)
{
    if (typeof(T) != this.GetType()) throw …;

Side note: Your decomposition looks pretty awkward. Groups of animals seem to be a concept that spans beyond a particular animal class, and so having groups being a member of an individual animal looks very counterintuitive from the data structure design perspective.