Best practices for logical const

[Adam D. Ruppe]

D doesn't have logical const, but sometimes it is useful, 
especially with lazy initialization of a field, and we can kinda 
fake it with casts or with global variables. Modifying an 
immutable object is undefined behavior, so how can we avoid that, 
and if not, try to minimize the problems in practice?

Using global variables to store local state is kinda silly, it 
seems to me that doing a AA lookup kinda defeats the point of 
caching in the first place, so I want to focus on the cast method.

So:

* should we always wrap the write in a synchronized block to 
minimize the chances that we'll have thread problems with 
implicitly shared immutable things passed as const? What's the 
best way to do this btw?

* should objects with logical const methods deliberately not 
provide immutable constructors to prevent them from being 
immutable? Would this actually work?

* Anything else that is likely to come up?