Here's a not-so-quick explanation about optimization :
**GPU Instancing**
GPU instancing is nice if you want to batch similar meshes. Unity also sorts those GPU instances front-to-back to reduce overdraw and therefore GPU usage. But, if you have multiple different GPU-instanced meshes in your scene (trees, rocks etc.), then Unity may render those instances in more batches to preserve front-to-back sorting, which increases CPU usage. For instance, Unity may render 10 trees, then 8 rocks, then 25 trees, then 12 rocks (4 draw calls) instead of just rendering 35 trees then 20 rocks (2 draw calls)
In that case, you may want to play around with the render queue to let Unity know that you want to do the sorting yourself. This is one case where using different render queues can reduce the number of draw calls, but that could increase overdraw.
In the scene below, each house shares the same mesh filter and material, so those houses can be GPU instanced. To reduce overdraw, you may want to render the houses first, then the road, and finally the sky. Use GPU instancing for things like trees, rocks, grass, etc.
**Static batching, manual mesh combine**
Static batching works well for meshes that share the same material, and it's sometimes preferable to manually combining meshes, since Unity can still cull the individual meshes. But Unity doesn't always do a good job at Static Batching meshes, there are editor tools that can improve it, you can try using tools like "CustomStaticBatching" (GitHub).
Static Batching increases build size, do not static batch hundreds of meshes that could be GPU instanced instead, the difference can be hundreds of MBs in the worst case (I've seen once a world where switching to GPU instancing reduced the world size from 100MB to 10MB)
Static Batching comes with a CPU overhead, manually combining meshes doesn't have that issue, but like I mentioned previously, you cannot individually cull meshes that have been manually combined into a single mesh.
Static Batching and manually combining meshes can increase overdraw, as individual polygons aren't sorted front-to-back.
**Front-to-back sorting**
I mentioned a bunch of time "front-to-back sorting": To keep it short, I am talking about pixels, you want to render the pixels closest to the camera first, since the GPU can avoid wasting time drawing pixels that will just be covered by something closer.
If you render pixels farther away first, the GPU doesn't know yet if something will be rendered in front of them later. If that happens, you end up drawing the same area multiple times. That's overdraw.
Now, you cannot sort pixels, but you can sort meshes, and that's what Unity tries to do. Sorting meshes front-to-back more or less sorts pixels front-to-back.
**Conclusion**
Optimizing CPU performance can decrease GPU performance, causing the performance to be even worse than before, and vice versa, optimization is complicated to tackle, and there's like I mentioned in the first comment a lot of "This is recommended, except when...".
Things I mentioned may be better to do in some cases, but can make the performance worse in others.