GitLab

- eliminates previous code duplication and improves maintainability

- use proxy writer for triSurface writing

- simplifies organization, includes, linkage etc.

- increases coverage.

STYLE: relocate some core pieces into fileFormats

- it doesn't actually contain 'core' code, but rather various
  instances of MeshedSurfaceProxy.

Note that since these actually act more like 'patches'
(ie, contiguous addressing) it might be reasonable to rename as

    surfPatchIdentifier / surfacePatchIdentifier

- This format is fortunately little-used (or never used) since its
  inception.

  Using raw stream operators to write zones, points and faces in a
  single file was not well thought out - the output content varies
  with the Face template type (face, triFace, labelledFace), which
  makes it not very robust at all.

  The static read in OFSsurfaceFormat also has a bug - keeping
  transcribed faces from being passed through.

  Conclusion: removing it makes more sense that repairing and still
  not having something good.

  Do retain stream operators for MeshedSurface and UnsortedMeshedSurface,
  since they are useful for passing around data
  (eg, between processors), but they shouldn't be used for files.

- For merging meshedSurf content from parallel sources.
  Ensures zoneIds are properly preserved for sampling in parallel.

Current state
~~~~~~~~~~~~~

Current producers of the region information:
 * sampledTriSurfaceMesh

Current consumers of the region information:
 * nastran writer. The zone ids passed through as PSHELL Ids (with offset 1).

Limitations

  The per-face region association is preserved, but the face/element
  sort order gets lost in reconstruction. Would need to attach
  additional information to the sampled surface and use that for
  sorting, but this would also imply that sampled values be written
  indirectly (or resorted) too to match the order. Zone ids are passed
  through, but not their names. After reconstruction, zone ids are no
  longer contiguous. Re-sorting (as mentioned above) would solve this
  too, but again at the cost of more complexity when writing.