Dead code, the law, and unintended consequences
Dead code is source code that is not executed in the final system. It comes in two forms. First, there is dead code that is commented out or removed via #ifdef's. That dead code has no corresponding form in the binary. Other dead code is present in the binary but cannot be or is never invoked. Either way, dead code is a vestige or unnecessary part of the product.
One of the places I have seen a lot of dead code is in my work as an expert witness. And I've observed that the presence of dead code can have unintended legal consequences. In at least one case I was involved in, it's likely that strings in certain dead code in the binary was a major cause of a lawsuit being brought against a maker of embedded system products. I've also observed several scenarios in which dead code (at least in part) heightened the probability of a loss in court.
One way that dead code can increases the probability of a loss in court is if the dead code implements part (or all) of a patented algorithm. When a patent infringement suit is brought against your company, one or more versions of your source code -- when potentially relevant -- must be produced to the other side's legal team. The patent owner's expert(s) will pore over this source code for many hours, seeking to identify portions of the code that implement each part of the algorithm. If one of those parts is implemented in dead code that becomes part of the binary, the product may still infringe an asserted claim of the patent -- even if it is never invoked. (I'm not a lawyer and not sure if dead code does legally infringe, but consider it at least possible that neither side's expert will notice it is dead or that the judge or jury won't be convinced by a dead code defense.)
Another potential consequence of dead code is that an expert assessing the quality of your source code (e.g., in a product liability suit involving injury or death) may use as one basis of her opinion of poor quality that the source code she examined is overly-complex and riddled with commented out code and/or preprocessing directives. As you know, source code that is hard to read is harder than it needs to be to maintain. And, I think most experts would agree, code that is hard to read and maintain is more likely to contain bugs.
In such a scenario, your engineering team may come off as sloppy or incompetent to the jury, which is not exactly the first impression you want to make when your product is alleged to have caused injury or death. Note that overly-complex code also increases the cost of litigation -- as both side's experts will need to spend more time reviewing the source code to understand it fully.