Strangely, code reuse is still a useful idea even when the code isn’t being reused.
Most code isn’t reused. Yet code reuse is still a popular idea. Why? Because when you design code to be reused you design code that is self contained. Code that makes sense on its own. Code that makes explicit anything it depends on.
Reusable code is readable code precisely because it doesn’t assume it knows about the world around it. So when you read it, you can ignore the world around it. That’s nice, even if you don’t actually reuse it.
So the next time some clairvoyant coder claims “this code will never be reused” tell them “we still plan on reading it”.
You don't need OOP to follow code reuse. You just need to be formal about any outside needs. No sneaky hidden dependencies. But you can do that in functional or OO paradigms.
Inheritance is just one of many ways to get Polymorphism. Polymorphism only figures into this if you need to allow flow of control to both go into and come out of your module without allowing outside dependencies. You can use polymorphism to invert the dependency. The isolation this allows helps keep your code reusable.
Decomposition helps with reuse simply because it shrinks what would be reused. That is, how much you have to think about at once. Turn one big thing into three little things and you only have to think about (reuse) one of them at a time.
Unit testing can be thought of as an example of reuse. I think of it more as a demonstration of how reuseable your code is. Reusable code tends to be testable code.
Really, the first reuse of code is when you read it. You run it in your head. Here is where a lot of time gets saved because code gets read far more often then it’s written. It’s very nice when what you have to read to understand code is small.
And of course if you’ve achieved reusable code it should be relatively easy to drop it into a new code base and make use of it. Doesn’t mean it’s ready to be in a 3rd party library. It just means the bloody stumps are at a minimum. This is nice, but not the point.
How reusability is achieved is far less important then that it is achieved. Whether you actually reuse it or not, we just want code that’s easy to read.