This is a summary of the thread to date. I've listed it as the solution so anyone checking gets the summary without reading the entire thread.
Initial question was effectively: Is preventing a .h file from being read multiple times worth while and what is the best way to provide the guarding?
There are two reasons to prevent multiple inclusions of a .h file. The primary reason is to prevent items from being defined multiple times since this usually results in compile errors. The secondary reason is to decrease compile time since the compiler has fewer lines to parse.
The obvious conclusion is that preventing compile errors is a necessary and sufficient reason to use preprocessor directives (#ifndef / #endif) to prevent multiple insertions.
There is discussion of the two basic approaches -- using the preprocessor #ifndef/#endif commands in the sketch to prevent the .h file from being opened OR using the commands inside the .h file.
The first case requires the sketch coder to individually bracket each .h file. The second approach requires the .h coder to include protection once in each .h file.
The conclusion seems to be that both work, neither is significantly faster than the other, and that for programs likely to run on an Arduino the difference is irrelevant.
A discussion of using #pragma once appeared on several other platforms and the conclusion was that, while #pragma once is not an official directive all of the current implementations support it. Unless you are writing for a very old compiler or one that you know does not support #pragma once it is an acceptable use.
Several people have put significant effort into testing preprocessor/compiler speeds so read the thread if interested in either the methods or results.
Thanks to everyone for asking questions I hadn't though of and providing answers.