Marking a method parameter as final is needed to allow for variable access by inner anonymous classes and is a useful coding-tool for enforcing certain variable use conventions within the method.
Apart from that, is there some other compilation-related motivation to use the final-keyword? Specifically, does it give the compiler any hints which facilitate some specific optimization that would otherwise not be performed? Or is the compiler smart enough to always recognize if a variable is never modified anyways?
For example, I'm thinking whether there is any difference how the variables are passed into the method. E.g. a variable of primitive type (int, byte, etc.) needs to be copied when passed into the method to prevent any modifications to trickle out into the calling code, whereas if the parameter is marked final, it could be "passed by reference" without such concerns, i.e. no copy-operation would be needed.
But let's keep the question more general than this example:
Are there scenarios where adding final to a method parameter will change the generated byte-code?
No there is not. This is purely a compile time check.
Note that bytecode is higher level then you seem to think - in particular there's no raw memory addresses. All parameter passing is abstracted away. Also, the Java compiler does very little optimization. The JIT is responsible for doing all the optimization at runtime.
Furthermore at the actual machine code level, passing a single word parameter by reference likely isn't going to optimize anything. Under normal circumstances, copying it will be faster (since it's in a register anyway). But again, this is all low level implementation details that the JIT worries about, not the purview of bytecode.