Is sharing base and derived class names a bad practice?

Question

Since people have requested more context, I will try to provide a concrete example of the problem. I am doing some sort of generic ERP system that displays the usage of resources in a diagram. I have some generic classes that are used to model the problem such as Job, Resource, and Operation. Something like this:

public class Job
    {
        public string ID { get; }
        public string Name { get; set; }
        public DateTime Arrival { get; }
        public Job(string id, DateTime arrival)
        {
            Arrival = arrival;
            ID = id;
        }
    }

public class Resource
    {
        public string ID { get; set; }
        public string Name { get; set; }
    protected Resource(Resource other) => ID    = other.ID;
    }

public class Operation
    {
        public string ID { get; }
        public string Name { get; set; }
        public Job ProcessedJob { get; }
        public Resource Processing Resource { get; }

        public Operation(string id, Job processedJob, Resource processingResource)
        {
            ID = id;
            ProcessedJob = processedJob;
            ProcessingResource = processingResource
        }
    }

However, the application is generic so this modeling may not be enough for all possible problems. For example, there may be Jobs that have properties such as the maximum time they can take to be processed or resources that have a certain schedule. The thing is that depending on the concrete problem I am modeling these characteristics may be part of the problem or not so expanding each class whenever a new problem case arises doesn't seem a good idea since it will pollute the code.

The obvious solution is inheriting from each base class and having a derived class for each problem case so that includes the desired properties, such as Problem1Job and Problem1Resource. In my opinion, this also gets messy if more problem cases or base classes are added because the total file count increases. An example of this could be (I didn't include constructors for the sake of clarity):

public class Problem1Job : Job
    {
        public bool ExtraPropertyA {get ; set; }
        public string ExtraPropertyB {get ; set; }
        public int ExtraPropertyC {get ; set; }
    }

public class Problem1Resource : Resource
    {
        public bool ExtraPropertyA {get ; set; }
        public int ExtraPropertyB {get ; set; }
    }

Instead of storing all these classes in one folder, I have decided to group all the base classes in one folder called base, with its own namespace, and create a folder for each of the problems with a different namespace. This allows me to create classes that are Job : base.Job and Resource : base.Resource inside the namespace Problem1, thus sharing the name with their base classes but in a different namespace. For me, it is a clean way to organize the files, but I don't know if there is any convention regarding sharing the names between the base and derived classes (given they are in different namespaces) or if it is considered a bad practice/code smell.