I agree with others that this seems overengineered. Usually, you want either a simple enum or a complex hierarchy of classes, it’s not a good idea to combine the two.

But if you really want to do this (in C#), I think it’s useful to recap what exactly do you want:

• Separate types for the hierarchy Kingdom, Phylum, etc., which do not form inheritance hierarchy (otherwise, Phylum could be assigned to Kingdom). Though they could inherit from a common base class.
• Each expression like Animalia.Chordata.Aves has to be assignable to a variable, which means we have to work with instances, not nested static types. This is especially problematic for the root type, because there are no global variables in C#. You could solve that by using a singleton. Also, I think there should be only one root, so the code above would become something like Organisms.Instance.Animalia.Chordata.Aves.
• Each member has to be a different type, so that Animalia.Chordata compiled, but Plantae.Chordata didn’t.
• Each member needs to somehow know all its children, for the IsMember() method to work.

The way I would implement these requirements is to start with a class like EnumSet<TChild> (though the name could be better), where TChild is the type of the children of this level in hierarchy. This class would also contain a collection of all its children (see later about filling it). We also need another type to represent leaf level of the hierarchy: non-generic EnumSet:

abstract class EnumSet
{}

abstract class EnumSet<TChild> : EnumSet where TChild : EnumSet
{
    protected IEnumerable<TChild> Children { get; private set; }

    public bool Contains(TChild child)
    {
        return Children.Contains(child);
    }
}

Now we need to create a class for each level in the hierarchy:

abstract class Root : EnumSet<Kingdom>
{}

abstract class Kingdom : EnumSet<Phylum>
{}

abstract class Phylum : EnumSet
{}

And finally some concrete classes:

class Organisms : Root
{
    public static readonly Organisms Instance = new Organisms();

    private Organisms()
    {}

    public readonly Animalia Animalia = new Animalia();
    public readonly Plantae Plantae = new Plantae();
}

class Plantae : Kingdom
{
    public readonly Anthophyta Anthophyta = new Anthophyta();
}

class Anthophyta : Phylum
{}

class Animalia : Kingdom
{
    public readonly Chordata Chordata = new Chordata();
}

class Chordata : Phylum
{}

Notice that children are always fields of the parent class. What this means is that to fill the Children collection, we can use reflection:

public EnumSet()
{
    Children = GetType().GetFields(BindingFlags.Instance | BindingFlags.Public)
                        .Select(f => f.GetValue(this))
                        .Cast<TChild>()
                        .ToArray();
}

One problem with this approach is that Contains() always works only one level down. So, you can do Organisms.Instance.Contains(animalia), but not .Contains(chordata). You can do that by adding overloads of Contains() to the specific hierarchy classes, e.g.:

abstract class Root : EnumSet<Kingdom>
{
    public bool Contains(Phylum phylum)
    {
        return Children.Any(c => c.Contains(phylum));
    }
}

But this would be a lot of work for deep hierarchies.

After all of this, you end up with quite a lot of repetitive code. One way to fix that would be to have a text file that describes the hierarchy and use a T4 template to generate all the classes based on that.

I think this is the best way you can implement it:
https://stackoverflow.com/a/24969525/538387

But as you see, it adds more complexity to the code, which is not a good practice in general.

I suggest to keep every enum values flat, just like a normal enum definition, and add a few extension or helper methods. like:

public enum Animal
{
    // Mammals
    Cat,
    Dog,
    Bear

    // Birds
    Pigeon,
    Hawk,
    Ostrich

    // Fishes
    Goldfish,
    Trout,
    Shark
};


public static class AnimalExtension
{
    public static bool IsMammal(this Animal animal)
    {
        return animal == Animal.Cat
            || animal == Animal.Dog
            || animal == Animal.Bear;
    }

    public static bool IsBird(this Animal animal)
    {
        ...
    }

    public static bool IsFish(this Animal animal)
    {
        ...
    }
}

So you can easily write in your code:

Animal animal = GetValueFromASource();

if (animal.IsMammal())
{
    Console.Write("This is a mammal.");
}

My solution would be to use bit flags. If you are not familiar see here. The general idea is simple yet still falls in line with your need to use enums.

Each grouping of, for lack of a better work, classes, is just a span of bits. So for mammals you just delegate a stretch of bits. In your case you would have your None(0x0) organism, perhaps the Platypus. Then 0x1 is Cat, 0x2 is dog, 0x4 is bear. To check for inclusion in the Mammals category just AND it with a 7 and be sure the result is the value being checked.

To check for inclusion in the Animal kingdom you would just AND it with the all bit flagged stretch of values you have.

This is not exactly the best technique for scalability but it may be the functionality you are looking for.

Enums are integral types and that is not going to change so whatever solution we come up with we can stop calling it an enum.

All speculation about bad design decisions aside, I suggest you use a string with a reserved separator character. The purpose is still identification, you just do not like the flatness.

So how about Animal_Mammal_Cat for an id?

You can easily split that into its subparts and process it using a nested switch statement. That will give you the opportunity to invoke custom handling based on the “class” of identifier you are dealing with.

It is not that uncommon in business administration to have identifiers that have contextual information in them. Like order number 202004201 as the first order on April 20th of 2020. Guaranteed to be unique, can be used a technical id (key) and provides a way to filter in time.