Generics are very useful for containers, they help maintain strong typing and reduce the number of casts. Outside of that, they can get a bit obtuse (IME). The built-in Delphi generics are quite inefficient though, so those are probably not a good idea in game code (not to mention the compiler isn't very good with them, and you can end up with weird internal compiler errors or huge executables).
For simple containers, they compete with arrays (dynamic or not), which typically have less overhead, and can be just as strongly-typed. So for games, I would say they're good outside performance-critical code, and the with caution.

Duck-typing I'm not a fan of, it's just too easy to let a dragon that can quack & walk into the pond (with devastating outcome).
Also many terms (in human language) are just too ambiguous, a good deal of programming is about removing the ambiguity to express what needs to be done clearly.

Await and asynchronicity are both useful and impractical for games, useful because it means you can use multi-core more easily, and impractical because unless you're on a console, you can't assume a certain number of cores are at your disposal, nor how much time it'll take to do something. So they can only be used for stuff peripheral to the game (like pre-loading textures, reducing wait between levels, etc.), but can't be used for anything time or frame-critical (unless you bump the requirements to things like "quad-core CPU required and I mean a real quad-core not just a dual-core with hyperthreading")

Nested classes, well the only practical use seems to be for enumerators, apart that, they just get too verbose and too specific.

for..in loops, they save some typing and improve clarity, I use them whenever I can

final methods & sealed classes: I use them mostly to guarantee a class isn't subclassed, which means you can do "if obj.ClassType=TSealedClass" rather than having to use "in". It's a micro-optimizations though, and may not be relevant in general, but it can have its uses.

anonymous methods: can be quite useful and reasonably efficient, though in the case of Delphi, be wary of compiler internal errors.