Freeciv

Part of #43927. Make all strings representing generated code have the same general shape so they can all be worked with the same way.

The style that seemed to work well when prototyping is as follows:

Functionally, strings that represent zero or more entire lines of code should

• have a line break at the end of each line (including the final line)
• have no line break before the first line

or, equivalently

• start with no line break (unless semantically starting with an empty line)
• end with a line break (unless empty)

Stylistically, strings that represent one or more entire lines of code should

• be multiline strings wrapped in """threefold double quotes"""
• have each line of C code be on its own line in the Python code. Accordingly
  • the opening quotes must be followed by an escaped line break, i.e. """\ at the start of the string
  • the closing quotes must be at the very beginning of a line after the last line of C code
• have each other, inserted string of lines of code be on its own line in the Python code
  • followed by an escaped line break, since the inserted string comes with its own final line break
• not contain \n, but rather write out blank lines explicitly
• not escape ' and " that occur in the C code

The empty string should be written as "" (using double quotes, not single quotes).

Functionally, strings that represent an expression that is not an entire line should

• contain no line breaks (since we'd need a more advanced prefix() function for those)
• have no padding or indentation

Stylistically, strings that represent an expression should

• be single-line strings wrapped in "double quotes"
• escape " that occur in the C code (rather than changing the quotes of the string itself)

Example:

 def an_expression(foobar) -> str:
     return "{foobar.func}({foobar.baz})".format(foobar = foobar)
 
 def some_lines(foobar: Foobar) -> str:
     return """\
 defoo(foos[{foobar.foo}]);
 foos[{foobar.foo}] = bars[{foobar.bar}].foo;
 enfoo(foos[{foobar.foo}]);
 """.format(foobar = foobar)
 
 def some_more_lines(foobar: Foobar) -> str:
     condition = an_expression(foobar)
     inner = prefix("  ", some_lines(foobar))
     return """\
 if ({condition}) {{
   log("Re-fooing {foobar.name}...")
 {inner}\
   re_foos++;
 }}
 """.format(foobar = foobar, condition = condition, inner = inner)

Note: All code being written as un-indented as possible (as in this example) is covered by #44977.