My goal is to eliminate the Adapters and Presenters and make the DTOs build themselves (within the constructor) and the Entities will also build themeselves. I just don't know exactly where I'll call new Entity(arg1, arg2, arg3, ...).

This is a bit of a frame challenge but I think you might be pursuing valuable goals but creating unnecessary challenges for yourself by limiting your toolbox to a constructor.

That is, if you wish to move all the logic around the creation of objects to the their classes, I think there's something to that. You can do that, however, without putting that logic into the constructor. I'm use Java as the scope here because I am familiar with it and because of the evolution of the language, I think this comes up a lot in Java solutions.

But first, let's think about what a constructor actually is for a moment. It's a function which can take inputs and produce an object. So in a real sense, it's a special kind of static method with extra capabilities and restrictions. One of the main restriction is that it has to return a newly created object (or fail.) You don't even get an option to return anything else, it's just implicit. This restriction means that constructors are defacto factory methods.

The main special capability in a constructor that is relevant here is the ability to set final variables in the resulting object. This is a really useful tool for creating immutable objects (IMO) which should be the way most objects are designed. Mutability should only be used when it supports a specific purpose. But this power also creates some limitations. You only get one shot at the assignment. This isn't normally and issue, but the upshot is that your constructor code is subject to more stringent rules than normal functions.

These rules are good because they ensure that any object created is valid but when assembling a complex object, they often make things more complicated than code outside of the constructor.

There's a simple answer to this: make your constructor simple and private. By simple I mean it does no more than assign parameters to members. No conditions, no logic. Just assignments. Then you can create one or more factory methods on the class. These factory methods can do all sorts of complex logic and call the simple constructor once the input parameters are determined. You can also support post creation logic such as modifying private members, wrapping the object, add references to collections for tracking, adding observers, etc. And you can do this without exposing the internals of the object to any other class. It's all managed in the same class definition as the constructor. Moving code from the constructor to a factory method a minor change to the structure of the class but the way it allows your simpler and more correct code can be dramatic.

My goal is to eliminate the Adapters and Presenters and make the DTOs build themselves (within the constructor) and the Entities will also build themeselves. I just don't know exactly where I'll call new Entity(arg1, arg2, arg3, ...).

This is a bit of a frame challenge but I think you might be pursuing valuable goals but creating unnecessary challenges for yourself by limiting your toolbox to a constructor.

That is, if you wish to move all the logic around the creation of objects to the their classes, I think there's something to that. You can do that, however, without putting that logic into the constructor. I'm use Java as the scope here because I am familiar with it and because of the evolution of the language, I think this comes up a lot in Java solutions.

But first, let's think about what a constructor actually is for a moment. It's a function which can take inputs and produce an object. So in a real sense, it's a special kind of static method with extra capabilities and restrictions. One of the main restriction is that it has to return a newly created object (or fail.) You don't even get an option to return anything else, it's just implicit. This restriction means that constructors are defacto factory methods.

The main special capability in a constructor that is relevant here is the ability to set final variables in the resulting object. This is a really useful tool for creating immutable objects (IMO) which should be the way most objects are designed. Mutability should only be used when it supports a specific purpose. But this power also creates some limitations. You only get one shot at the assignment. This isn't normally an issue, but the upshot is that your constructor code is subject to more stringent rules than normal functions.

These rules are good because they ensure that any object created is valid but when assembling a complex object, they often make things more complicated than code outside of the constructor.

There's a simple answer to this: make your constructor simple and private. By simple I mean it does no more than assign parameters to members. No conditions, no logic. Just assignments. Then you can create one or more factory methods on the class. These factory methods can do all sorts of complex logic and call the simple constructor once the input parameters are determined. You can also support post creation logic such as modifying private members, wrapping the object, add references to collections for tracking, adding observers, etc. And you can do this without exposing the internals of the object to any other class. It's all managed in the same class definition as the constructor. Moving code from the constructor to a factory method a minor change to the structure of the class but the way it allows for simpler and more correct code can be dramatic.