String encapsulation for improved translation

Forgetting to add the `%d` does not cause a crash. However, I agree that `%d` (and `%s`, etc.) are hard to follow. Moreover, `%d` still maintains crippling inflexibilities for the localization effort because positions are set in stone. Does closing a pull request effectively cancel it? I'd like to talk this over further first instead of making any more immediate changes.

You could take a hard-line position and say translators should never have to deal with variables in any form. I think that will not only result in a suboptimal localization, but also in a suboptimal original. The "page 2/10" hack perfectly demonstrates the problem. If you used the much nicer "page 2 of 10", you'd end up with something unwieldy like `_"page" .. " " .. page .. _"of" .. " " .. page_total`. The added complexity of "where does this particular 'of' belong?" is far worse than that of variables. In this case the complexity is bypassed by hardcoding `/`. In Perl or some such you could write the much clearer form `page $page of $page_total` and you'd have full positional flexibility. In Python you have the  you can achieve the same flexibility by using `"There are {page_total} pages. Currently we're on page {page}".format(page=2, page_total=10)`.

It seems to be easy enough to achieve the same thing in Lua (see [here](http://lua-users.org/wiki/StringInterpolation)), although I don't know if extending the modulo prototype is a good idea for future compatibility.
```
function interp(s, tab)
    return (s:gsub('($%b{})', function(w) return tab[w:sub(3, -2)] or w end))
end
getmetatable("").__mod = interp

print( "${name} is ${value}" % {name = "foo", value = "bar"} )
-- Outputs "foo is bar"
```
The following solution avoids doing anything that could break, however unlikely that might be.
```
function replace_vars(str, vars)
  -- Allow replace_vars{str, vars} syntax as well as replace_vars(str, {vars})
  if not vars then
    vars = str
    str = vars[1]
  end
  return (string_gsub(str, "({([^}]+)})",
    function(whole,i)
      return vars[i] or whole
    end))
end

-- Example:
output = replace{
	[[Hello {name}, welcome to {company}. ]],
	name = name,
	company = get_company_name()
}
```
To summarize, my argument is that flexible, intelligible variables in the form of, e.g., `${variable}` or `{variable}` will be a boon to the localization effort when used sparingly, and it will also improve the English original.