If you're calling Model.foo or Model.bar, you don't care about the specific implementation, you just want foo or bar.
The calling code doesn't need to know how Model works.
This way you can refactor either ones into normal attributes down the road without changing any dependant code.
If I care to call person.eye_color, I don't care (as the caller) how Person implements eye_color (it may be a simple attribute or do some ridiculously slow color calculation) - if I need the color, I need the color. Now, that's not to say that performance doesn't matter, just that any performance concerns should be addressed in Person, not in trying discourage caller from calling eye_color and trying to get at that value some other way.
That same logic would suggest that we should name our methods Model.foo_slow() and Model.bar_fast() because the execution speed is important and should be transparent to the caller.
In practice, Model.foo() ends up often being memoized so that all but the first call are practically equivalent to accessing an attribute.
Your suggestion violates the uniform access principle: http://en.wikipedia.org/wiki/Uniform_access_principle