Use Sphinx-compatible docstring format in PyDocConverter.

Use the more or less standard :param:, :type:, :return: and :raises: in the
function/methods descriptions.

Update the output expected from the Python tests accordingly.
Use reST inline markup in PyDocConverter instead of Markdown.

reST is standard Python markup, so use *...*, ``...`` and so on instead of
_..._, '...' etc.

No other changes even though the mapping of some Doxygen tags to markup used
for them seems suspicions (e.g. \var almost certainly should be the same as
\em).
Attach Doxygen comments to enum elements in Python output.

Sphinx is smart enough to use the docstrings following the constant definition
in Python code as its documentation, so doing this is still useful even if
Python itself doesn't support having docstrings for the variables (and this is
why it's impractical to write a unit test for the changes of this commit: we
can't easily extract the generated docstrings).
Hack to ignore custom "noexport" and "iterator" Doxygen commands.

There is no mechanism for registering custom Doxygen keywords (akin to Doxygen
own @alias), so just hard code these two for now.
Implement translation of Doxygen formulae to Sphinx notation.

This allows to automatically have nicely looking formulae in HTML output when
using Sphinx with e.g. sphinx.ext.mathjax extension.
Fix memory leaks in Doxygen to PyDoc parameter types conversion code.

Don't forget to delete the local copy of parameter list and the temporary
string.
No real changes, just rewrite the parameter iteration loop to be more clear.

Also remove unused commented out code.
Use Python-ish, not C++, parameter types in Python documentation.

Using C++ types in documentation for Python users is more harmful than
useless, so use Python types whenever possible and allow defining "doctype"
typemap to customize this for the user-defined types.
Add poor man trailing white space detection to Doxygen Python tests.

Show that there is trailing white space in the output in an ugly but
functional way, as without this it's impossible to determine what is the
actual change at all.
Use Sphinx-friendly formatting for overloaded functions documentation.

Sphinx doesn't allow sections inside the function documentation and gives tons
of SEVERE warnings for them, so while just emphasizing the "Overload" header
is not ideal, it is better than before because at least the string "Overload"
itself appears in the Sphinx-generated output.
Preserve relative indentation when parsing Doxygen comments.

This is important to preserve the structure of the lists which appear
correctly in Python output without any additional effort if the indentation is
lost.

It is also makes the behaviour consistent for

	/**
	 *
	 *
	 */

comments and those without the asterisks in the middle lines, as now the
indentation is preserved in both cases while it was only preserved when the
asterisks were present previously.
No real changes, just remove an unnecessary variable.

Avoid copying "pyDocString" to "result" completely unnecessary, just use
"pyDocString" itself directly.
Remove unused method from PyDocConverter.

justifyString() was unused and doesn't seem to be useful as there are no
particular constraints on the line length in Python documentation, so just
preserve whatever is used in the original C++ code.
Fix arguments of @param, @return etc translations to Python.

For the parameter documentation to be really taken as such, in its entirety,
by Sphinx, it must be indented relative to the :param: tag. Do this by
appending an extra indent after every line of the output and work around the
unnecessary indent of the last line by removing the trailing whitespace.

This required updating the existing tests and removing the expected but not
present any more whitespace from them, but as trailing whitespace in the
documentation is at best insignificant (and at worst harmful) anyhow, this is
not a big price to pay for simpler translator code.
Make Language::classLookup() and enumLookup() static.

This will allow to reuse them in the code that doesn't have access to a
Language object, such as DoxygenTranslator implementation.

These methods didn't really use any of Language object non-static fields
anyhow, the only one they did use (classtypes or enumtypes, respectively), was
only used for caching and can just as well be made local to the function
itself as long as we use other global variables anyhow.
Make Python parameters types hyperlinks in the doc strings.

It is very useful to be able to click on the parameter types in a function
documentation to go to this parameter description, so always use hyperlink
markup for the parameters of class types, even if not all of them are
necessarily documented -- Sphinx doesn't seem to complain about links to
unknown classes.
Add a simple test of multiple parameters to Doxygen test suite.

Ensure that translating more than one @param tag works correctly.
Translate Doxygen code blocks to Sphinx code blocks.

This ensures they are formatted correctly and syntax highlighted (currently
always as C++ code).
Simplify and make more efficient building Python docstrings.

Make the rules for combining explicitly specified docstring, autodoc one and
the one obtained by translating Doxygen comments implicit in the structure of
the code itself instead of writing complicated conditions checking them.

This results in small changes to the whitespace in the generated Python code
when using autodoc, but this makes it PEP 8-compliant, so it is the right
thing to do anyhow.

Also cache the docstring built from translated Doxygen comments. The existing
code seemed to intend to do it, but didn't, really. This helps with
performance generally speaking (-10% for a relatively big library using a lot
of Doxygen comments) and also makes debugging Doxygen translation code less
painful as it's executed only once instead of twice for each comment.

Finally, avoid putting "r", used for Python raw strings, into docstrings in C
code, it is really not needed there.
Remove long line wrapping from Python parameter list generation code.

This doesn't play well with PEP8 checks which imposes very strict continuation
line indentation rules which need to be _visually_ aligned, i.e. the subsequent
lines must be indented by the position of the opening bracket in the function
declaration line, but the code generating the parameter lists doesn't have
this information and so it's impossible to do it while avoiding either E128 or
E123 ("continuation line {under,over}-indented for visual indent" respectively)
error from pep8.

Moreover, the wrapping code didn't work correctly anyhow as it only took into
account the length of the parameter list itself and not the total line length,
which should include the function name as well.

So just disable wrapping entirely, long lines shouldn't be a problem anyhow in
auto-generated code.