Trying to identify the best method for IIR realizations I'm relatively new to implementing IIR filters in raw programming formats (i.e. C or C++) and I've run into the concept of IIR filter realizations. 

So my question: is there a 'best format (works 99% of the time)' for implementing these filters? i.e. an implementation that will typically be 'best' regardless of the application? Or is the actual implementation highly dependent on the application?

Here's an array of smaller yet related questions:


Is there ever an application in IIR filters where implementing the direct form of the filter is beneficial? Or should I always attempt to realize the filter as a cascade of subsystems?
Regarding cascade and parallel realizations, is cascaded always better?
Assuming that the exact filter implementation is dependent on the application, is it worth the effort to spend time and analyze the filter implementation from the beginning, or should I always aim for implementing as a cascaded subsystem and only deviate from that if the results are poor?
What is the purpose of transposed systems? I understand mathematically the differences, however, are there actual physical benefits of implementing a transposed vs nontransposed system?
I don't think "regardless of application" works here. Every application has different requirements and hence the optimum choice would be different. 

However in gross oversimplification


Direct Form I is the "safest choice". Direct Form II is slightly better since it has only half the amount of state variables. Stay away from Direct Form II and Transposed Form I since the transfer functions to the state variables are only determined by the poles and there can be massive gain scaling issues
Cascaded is the easiest choice. It's fairly simple to convert between poles and zeros and actual filter coefficients. Parallel requires calculating the roots of a large polynomial which is a numerically ill defined problem. 
There are different ways to pair poles and zeros to create second order sections. Best one is this : http://scipy.github.io/devdocs/generated/scipy.signal.zpk2sos.html 
Use floating point whenever possible. Fixed point IIR requires very careful analysis and application specific implementation. 
Whether optimization is worth it really depends on the application. Requirements can be all over the place: precision, speed, memory, mips, ease of us, stability against outlier condition, etc.