There are various projects like DNSSEC and DNSCrypt that aim to prevent DNS poisoning, etc. Adoption of these sorts of technologies are increasing, but not quite there yet.
Let's differentiate between control of your DNS server, control of the domain name, and control of the web server though.
If an attacker has control of a DNS server, they can send you to their attack server, but they can't forge a trusted certificate. This is easy to see as you'll get a 'this site isn't trusted'.
However, if an attacker were to get your account info for your domain registrar, then they could register their own IP with your domain name, which they could then channel into getting trusted certificate for that domain.
If an attacker has control of the webserver, then they could get a trusted certificate for that domain; this is entirely independent of DNS.
For the later two attacks, it's very hard to detect. Monitoring IPs isn't very useful in most cases, as a lot of website use cloud hosted (amazon, azure, google) where their IP can change day to day. You could monitor the certificates, a new certificate would have a different fingerprint, which you could detect client side (and could probably be automated with a browser plugin). However, certificates legitimately change every few years -- certificates expire after a set period by design -- so this could produce lots of false positives.
In short, if an attacker can steal a websites identity either by hijacking the domain via the registrar or just getting access to the existing webserver, it is very hard for a client to detect that. It is up to the website admins to make sure they keep control of their identity.
To the last point about zeroSSL/let's encrypt/ and those sorts of automated certificate providers. There have been a number of high profile cases where these automated systems have been generating certificates they shouldn't be (certificates where control of the domain isn't being properly validated). In this case, the fault lies entirely on the CA (ZeroSSL/Let's Encrypt/etc.), and exposes the inherent problem with allowing algorithms to handle validation. It's fast and cheap, but algorithms can be tricked in ways that humans intuitively know are tricks.