Is it true that Taproot addresses are just the Public Key encoded in bech32m?
Yes.
And native Segwit addresses are a hash of the Public Key encoded in bech32?
Yes.
Are the assumptions correct or do I have a misconception somewhere?
Yes, they are correct.
Taproot addresses are not just the public key encoded in bech32m; they are a combination of the public key and the Taproot script.
They don't have to be. You can spend by key, or spend by TapScript. Both paths are valid. There is always some public key, and if you know the private key, then you can entirely skip the script path, and always spend directly by key. Unless you have some invalid public key, where your x-coordinate does not correspond to any secp256k1 point. But in that case, it is simply unspendable, both by key, and by TapScript.
And Native Segregated Witness (SegWit) addresses are derived from the public key but are not a direct hash of the public key.
There is a direct hash. If you execute OP_HASH160 on some public key, you will get the hash, that corresponds to some P2WPKH address. If that key will be compressed, then for a given public key, that hash will be identical in P2WPKH and P2PKH addresses.
Anyway breaking in the elliptic curve would allow an attacker to get private keys either it's Taproot address or Segwit address
Not exactly. If secp256k1 will be broken, then:
1. All Taproot addresses could be spend by key.
2. All hash-based addresses could be spent, if the public key is revealed (so if a transaction is in mempool, or if there were previous transactions in past blocks). If the public key is unknown, then those coins will be unaffected.
3. All Lightning Network channels could be broken, as well as all other multi-party protocols, where you have any kind of multisig.
4. All signatures based on those public keys will be useless.
However, public key is called "public" for a reason. If it will be broken, then it should be replaced just by another address type, with another public key, on another curve, or completely different algorithm, for example lattice-based. Breaking public keys is just one-time-theft: when funds will move into another address type, then they will be safe again. Breaking hash functions could be more dangerous, because if you break SHA-256 on preimage level, then you can not only produce any hash, but also use hashing to produce any ECDSA-valid signature (just because message hash is signed, and if you can control that, then you can control ECDSA as well, you can easily confirm that, if you replace SHA-256 with some broken hash function, and try to produce a valid signature).
but the possibility of happening is not feasible even with the existing most powerful computer of this world
This is true as well. There are many topics, where people are worried "what could happen if ECDSA will be broken", or the same for SHA-256, but the truth is, that today, we are still far from that. We are not even close. In case of SHA-256, you can trace that by checking chainwork. In case of ECDSA, we have this famous puzzle, where 120-bit and 125-bit public keys were broken, and 130-bit key is still untouched (but as this puzzle is not provably fair, that proof is only useful to the puzzle creator, there are no proofs for other people that unsolved keys are in correct ranges, or that the creator didn't move the coins by himself).