It's very rare in gamedev to have a single optimum / perfect answer to anything - there are so many interacting concerns that we're constantly forced to make judgement calls between.
For instance, to a first approximation, combining textures so we can render more objects in a single pass is preferred, because it saves us draw calls which are often a limiting factor on our game's performace. But if you're not draw call bound (say you're using only a dozen different passes) then you might not see any benefit from this at all. And it's not without downsides:
Content rendered in a single pass usually needs to share one set of transform data. (Ignoring instancing for the moment) This is easiest to accomplish with static scene geometry, or small batches of simple dynamic objects that you bake into a shared buffer CPU-side, so it might not even apply to everything you want to render in your scene.
Setting up your textures and object UVs to use the atlas rather than their own texture space is an extra step in your asset creation workflow (and possible blocking point if two artists need to work on objects in the same atlas), or an extra process you need to build into your importer pipeline if it doesn't do it out of the box.
If your typical game scenes use only a few objects but in random combinations, pulling in a giant pre-baked atlas that covers every combination might make your loading times longer than you'd need if you just loaded each texture individually.
You could instead generate the atlas dynamically, hosting only the textures you need for the present scene, but that management layer adds a lot of complexity to your code, which might not be worth the development effort it will cost you if you're not seeing big wins from saving draw calls.
We're also limited by the maximum texture size that a given platform will support (particularly on older platforms that don't let us combine textures in arrays), which can put an upper bound on how many objects we can combine onto a single texture.
Finally, increasing texture size isn't the only way to improve detail. You're unlikely to want to paint every square meter of the game world in 4096 resolution, just in case a player with a 4K monitor decides to ram their camera straight into every wall & prop to see it as magnified as possible. You might instead layer repeating detail & grime textures at high magnification to break up interpolation artifacts. (Those textures might be in their own separate array, since you need a second sample anyway)
This is just a rough sampling of some of the different concerns a game development team would need to weigh when deciding on a batching / atlassing strategy, and it doesn't have a single common answer or formula that will be right for every game.