Update devel/gnustep-objc to 2.1.0 and fix its build

Highlights of 2.1.0 release include:

- Numerous improvements to the Objective-C++ exception interoperation code.
  The runtime now dynamically detects whether the libcxxrt or libsupc++ variant
  of the Itanium C++ Exception ABI is being used

- Sending a message to `super` where the corresponding method did not exist was
  silently ignored in previous versions of the runtime.  This now correctly
  invokes the forwarding hooks and so (with an implementation of the Foundation
  framework, such as GNUstep Base or WinObjC) will trigger an exception or
  invoke `forwardInvocation:`.

- The checks for overloaded memory management methods were incorrect, causing
  some classes to be incorrectly opted into ARC fast paths.  These checks are
  now correct.

- Several memory management bugs in corner cases of weak reference management
  were fixed.

- The ARM assembly implementation of `objc_msgSend` now correctly restores the
  stack after calling a forwarding implementation.  This bug caused stack
  corruption and usually crashing on ARM.

- The ARC code has been rewritten as C++, using a well-tested third-party
  Robin-Hood hash table to store weak references, replacing the home-grown
  version.  This improves performance and reduces the likelihood of bugs
  arising from the hash table implementation.

- Control Flow Guard (CGF) checks were added on Windows on x86 (32- and
  64-bit).  If Objective-C code is compiled with CFG enabled then
  `objc_msgSend` will crash if it attempts to jump to an address that is not a
  valid function entry point.

- The function signatures in the blocks headers were updated for compatibility
  with recent macOS releases.

- Support for the C11 _Atomic type qualifier in property metadata was added.

Highlights of 2.0.0 release include:

- The linker now removes duplicate selectors within a library.

- The linker will remove duplicate protocol definitions within a library.

- Protocols and classes are now always accessed via an indirection layer, so
  they can be extended by future versions of the ABI without breaking
  compatibility.

- Categories can include property metadata and both categories.

- Constant strings are now emitted with a richer structure, which provides
  faster hashing and better unicode support.

- Instance variable metadata includes size and alignment, allowing better object
  layout and more accurate introspection.  Instance variable metadata now
  includes more accurate information about ARC ownership semantics.

- Method metadata now includes extended type information, allowing bridged
  languages to understand the class that methods expect and not just the fact
  that they take an object.  This was previously an obstacle to supporting
  JavaScriptCore's Objective-C bridge with GNUstep.

In addition to the new ABI, there are several improvements on Windows:

- The runtime now uses SEH-based exception handling on Windows.  This
  interoperates with C++ exceptions in libraries compiled with MSVC or
  MSVC-compatible compilers.

- All of the assembly code paths now fully support i386 and x64 Windows.

- Object allocations on 32-bit Windows now use `_aligned_malloc` to guarantee
  sufficient alignment for AVX vectors in instance variables.

- The runtime now uses fibre-local storage and critical sections on Windows,
  improving performance in multithreaded workloads on Windows.

- Public runtime functions are now marked dllexport, so the runtime can be built
  as objc.dll on Windows.

**WARNING**: The new ABI is currently incompatible with incremental linking on
Windows, so projects built with Microsoft's linker must disable incremental
linking.

Note: Microsoft's WinObjC project contains a friendly fork of this library that
includes a work around for the incremental linking issue.  If you wish to use
incremental linking on Windows, please use that version.  A subsequent version
of clang and link.exe should include a fix that will make it possible to use
this version with incremental linking.

The runtime will now use the new ABI's data structures internally and will
automatically upgrade on-disk structures from old ABIs when used with the old
ABI.  As a result, memory usage will be higher when using the old ABI and users
who are unable to recompile their code may prefer to stick with the 1.9.x
release series.  Mixing libraries compiled with the old and new ABIs is not
supported and will abort at run time.

The new ABI provides better run-time introspection metadata and smaller
binaries.  When used with the new ABI, this version of the runtime will consume
less memory than the previous release.

Highlights of 1.9.0 release include:

- Support for 64-bit ARM (AArch64) processors, including assembly fast paths
  for message sending.

- Improved the dispatch table representation to improve performance and cache
  usage on the fast path.

- The implementation of `imp_implementationWithBlock`, the function that allows
  blocks to be used as methods, no longer requires physical pages to be mapped
  both writeable and executable.

- Numerous improvements to the interaction between runtime functions and ARC.

- Support for Thumb-2 interworking on ARM.  Note that the library must be
  compiled for ARMv7 or ARMv6T2 for this code to be enabled.  Once it has been,
  other Objective-C binaries linked with the library can be compiled as ARM or
  Thumb-2 code.  This will also generate Thumb-2 message send functions,
  improving instruction cache usage.

- Significant improvements to ARC, including

  * The runtime no longer acquires a global lock on every object deallocation (a
    global lock is still used for objects that have weak references). *NOTE:*
    This is incompatible with other code directly inspecting the reference
    count and will break with older versions of GNUstep Base!

  * Weak references use a scheme closer to C++ `std::weak_pointer` and are
    lazily zeroed on access.  This reduces the space overheads for weak
    references.

  * Some additional helper functions are added for use in `NSObject` and other
    root classes,  which simplifies the layering between the runtime and the
    Foundation (or equivalent) implementation.

- Improvements to how the runtime handles layout of ivars with strong alignment
  requirements, which should fix issues relating to using vector types in
  Objective-C objects.

- The option to build a separate libobjcxx has been removed.  The runtime will
  now depend on the C++ standard library implementation if no useable C++
  runtime is available.  Note that C++ exception interworking does not work
  because LLVM's libc++abi (shipped by Apple) does not provide GNU-compatible
  hooks and so Objective-C++ exception support will be automatically disabled
  on this platform.  Any other platforms shipping libc++abi should consider
  either GNU libsupc++ or libcxxrt as an alternative

(manu)