For symmetric cryptography: use algorithms with 256-bit strength, such as SHA-512, SHA3-512, SHAKE256, KMAC256, HMAC-SHA-512, Chacha20-Poly1305, AES-256 (in various modes, preferably AEAD modes), Camellia-256 (ditto). Few people will commit to any prediction of security in 30 years, although Ecrypt does. NIST also have recommendations but they don't go as far as 2051. Using robust algorithms in their maximum strength is your best bet anyway. All of these are widely implemented algorithms.
For asymmetric cryptography: nobody knows. If quantum computers work the way we think they might work, they will completely break all the asymmetric cryptography that's in use today. (In contrast, for symmetric cryptography, the effect will be merely to halve the resistance for a given key size.) And if the physics does work, then it's reasonable to think that the technology will get there in less than 30 years. There is an effort to standardize post-quantum cryptography (PQC), but it's still at an exploratory stage, where some cryptographers propose methods and their colleagues try to break them, sometimes successfully, sometimes not. In the short term, PQC is more risky than well-established asymmetric cryptography based on factoring (RSA) or discrete logarithm (ECC).
The only way to keep a device secure for years, let alone decades, is to keep updating it. Make sure your system has cryptographic agility, i.e. the ability to change which cryptographic primitives it uses. For asymmetric cryptography, you can test agility today by supporting both finite-field methods (RSA, DH) and ECC. You can also start implementing PQC methods, but keep in mind that they're likely to evolve rapidly in the next few years. Implementing PQC methods now is a good idea, at least as testing-only features, because they have an impact on system design: they are not drop-in replacements for classic primitives. For example, many PQC signature schemes are stateful: you can't just generate a key once and keep signing an arbitrary large number of messages. PQC signatures and keys also tend to be much larger than classic ones.
The ability to upgrade is important not just for the ability to change cryptographic algorithms. It must also be possible to fix software bugs and to implement resistance to new attacks. Attacks only every get better, and attack techniques that are considered exotic today may become commonplace tomorrow. For example, fault injection attacks were for a long time only a concern on very high-security devices such as smart cards and certain military applications. Then came rowhammer, which showed that fault injection can be carried out on a PC, purely in software. In 30 years, it's likely that the attack techniques will improve a lot, and no software made today will still be secure. Be updated or be pwned.
The software assurance level is pretty much irrelevant to the choice of cryptographic mechanism. It's relevant to the choice of implementation: a higher assurance level means an implementation with better design, more extensive testing, more countermeasures for side channel and fault injection attacks, etc. It's also relevant to where cryptography is used: a higher level tends to require more redundant controls (for example, you may need to have better resistance to hardware tampering, which requires additional encryption inside the device). But even at the most basic level of assurance, cryptography pretty much starts at “unbreakable assuming a perfect implementation”.