C#, VB.NET, Python, JavaScript, now even C++0x provides first-class functions.
Update:
An implementation of closures requires lambda-lifting - a technique originally quite alien for the imperative programmers. Proper first-class functions (which includes closures) requires at least some support from the runtime and VM. It also took some time to adopt the old functional techniques into the imperative world.
And, the most important part - first-class functions are barely usable if there is no garbage collection present. It was introduced into a mass programming only recently, with Java and, consequently, .NET. And the original Java approach was to oversimplify the language in order to keep it comprehandable by the average coders. .NET first followed, and only recently parted from that (IMHO, quite justified and appropriate) direction.
All such concepts takes time to be digested by the industry.
Arguably they are supported in virtually every programming language.
What you need are "assertions".
These are easily coded as "if" statements:
if (!assertion) then AssertionFailure();
With this, you can write contracts by placing such assertions at the top of your code for input constraints; those at the return points are output constraints. You can even add invariants throughout your code (although aren't really part of "design by contract").
So I argue they aren't widespread because programmers are too lazy to code them, not because you can't do it.
You can make these a little more efficient in most languages by defining a compile-time boolean constant "checking" and revising the statements a bit:
if (checking & !Assertion) then AssertionFailure();
If you don't like the syntax, you can resort to various language abstraction techniques such as macros.
Some modern languages give you nice syntax for this, and that's what I think you mean by "modern language support". That's support, but its pretty thin.
What most of even the modern languages don't give you is "temporal" assertions (over arbitrary previous or following states [temporal operator "eventually"], which you need if you want to write really interesting contracts. IF statements won't help you here.
Best Answer
I am of the opinion that if a language has macros, they should be a well planned out and integral part of the language and not of the compiler.
Example, Lisp's macro system is a very powerful integrated language feature and is subject to all the rules and regulations of Lisp itself.
Counter-example, C/C++ macro system is separate from the language and built into the compiler. The result is that you are not limited to the constraints of your language and can create invalid code and redefine language specific keywords.
At the end of the day, there are several languages that have no macro feature--but those fatures are not missed as much. It all depends on how expressive a language is, and whether it has alternative approaches to meta-programming. Meta-programming is just a way of ensuring that when you do X, X is done the same way all throughout the application.