String encapsulation for improved translation

I'll approach this argument from what the English-speaking world calls a humananities perspective, because that is perhaps where translators on the whole are most likely to originate. In the modern world I imagine most of us would encounter variables in the context of mathematics first, but instead I'll start with philosophy. The structure of a sample basic argument looks like this:

1. All `A`s are `B`s.
2. `C` is an `A`.
3. Therefore `C` is a `B`.

The actual values attached to the content of the argument are irrelevant, but what I had in mind while writing it was the classic of Socrates' mortality. This is taught early on in introduction to philosophy, as well as in Dutch class where fallacies are formally — and I might add, needlessly obtusely — described in terms of `p`, `q`, `r`, and `s`. Indeed, that is formal logic.

Moving on to higher education for a second, in linguistics we use [variables like NP, VP, N, etc.](https://en.wikipedia.org/wiki/Phrase_structure_rules) to describe the structure of sentences and how they can be generated algorithmically. There are also transformation rules that describe which sentence role a replacement element takes up. This is all highly abstract and I won't bore you with the details. Suffice it to say that complex tree structures consisting of variables generated by algorithms that are simple when taken one step at a time should be child's play to anyone with a language degree.

Returning to high school: in mathematics and physics everyone knows how to use variables. Perhaps there are people who have trouble with differential stuff like dx/dy, complex numbers, et cetera, but everybody knows how to solve `f(x)=2x` for any value of `x`. More from physics than from mathematics directly, everyone's familiar with formulas like `F=m*a`. 

I do not believe that variables are hard to understand in principle, especially if they have non-cryptic names. As an important side note, `page` and `page_num` are cryptic names, because `page_num` in this case actually refers to the total number of pages. This also applies while reading the code, but it takes on a whole new significance for localization. The variable names need to be as to the point as possible. Taking this further from my own experience, the first time I saw stuff like `$1` and `$2` (or `%d`) I had no idea just what was going on. But the first time I saw something like `$user` I immediately understood.

Perhaps this means that the variables should be, from a programmers perspective, extremely long-winded. A syntax like I described above will make this easy to do without annoying any programmers.
```
self.page_info_text.text = util.stringformat{_("page {page_number} of {page_total}"), page_number=self.page, page_total=self.page_num)}
```
Instead of a cryptic, inflexible `"page %d/%d"` we would have a wonderfully transparent and flexible `"page {page_number} of {page_total}"`.

From a localization perspective I now realize that the only real question is what syntax we should commit ourselves to. I propose we follow Python, but I haven't even scratched the surface of the range of possibilities.