Resolve "Refactor API conversion types"

This MR separates the functionality of `managed_rpc_type<T>` into
dedicated lifetime management types and conversion functions. This
makes for clearer the code since it is now possible to know when
a conversion is performed.

Lifetime management for C-types is now done with the `managed_ctype<T>`
types, which act only as holders of dynamically allocated C types and do not
perform any type conversions whatsoever.

Type conversions are now done with the `T1 convert(T2 obj)` family of functions.
When converting from CXX to C API types, these functions effectively
return instances of the appropriate `managed_ctype<T>`s. If one wishes to
relinquish ownership of the content of the `managed_ctype<T>` (e.g. to
pass it to a pure C function that will release it), this can be done
with the `managed_ctype<T>::release()` function.

Closes #46

See merge request !32

This commit separates the functionality of managed_rpc_type<T> into
dedicated lifetime management types and conversion functions. This
makes for clearer the code since it is now possible to know when
a conversion is performed.

Lifetime management for C-types is now done with the managed_ctype<T>
types, which act only as holders of dynamically allocated C types and do not
perform any type conversions whatsoever.

Type conversions are now done with the T1 convert(T2 obj) family of functions.
When converting from CXX to C API types, these functions effectively
return instances of the appropriate managed_ctype<T>s. If one wishes to
relinquish ownership of the content of the managed_ctype<T> (e.g. to
pass it to a pure C function that will release it), this can be done
with the managed_ctype<T>::release() function.

Resolve "Enable `-Werror` build flag"

Closes #42

See merge request !29

Resolve "Enable ASan build profile in CI"

This MR enables the usage of the ASan build configuration profile in the CI. This makes it so that CMake builds all binaries with ASan support, which in turn allows us to run all tests under ASan automatically.

Closes #43

See merge request !28

Merge branch '29-fix-adm_register_pfs_storage-adm_remove_pfs_storage-and-adm_update_pfs_storage' into 'main'

Resolve "Fix ADM_register_pfs_storage, ADM_remove_pfs_storage and ADM_update_pfs_storage"

Closes #29

See merge request !27

Fix missing definitions of ADM_register_pfs_storage, ADM_update_pfs_storage and ADM_remove_pfs_storage

Resolve "Integrate AGIOS in build system"

This MR adds AGIOS to the build system as a dependency for `scord` and `scord-ctl`.

Closes #15

See merge request !20

Resolve "Implement complex RPC arguments for ADM_register_job(), ADM_update_job() and ADM_remove_job()"

This MR implements the transmission of the complex RPC arguments required for the RPCs `ADM_register_job`, `ADM_update_job`, and `ADM_remove_job`.

It also makes the following deep changes to the source code:

1. The library core no longer uses C types for those RPCs. Also, C++ types 
   for those RPCs follow the [pimpl](https://en.cppreference.com/w/cpp/language/pimpl) 
   idiom to hide implementation details from the public API.
2. Refactors admire types by moving them to a dedicated 'admire_types' CMake target
   This makes it much simpler to share type definitions between the library
   and the daemons. Code structure is affected as follows:
    
   - C++ types are now declared in admire_types.hpp
   - C & C++ types are defined in types.cpp. The reason for them being in
     the same file is that the C type-creation functions use logging
     facilities that are C++ code. Until we offer a C interface for them,
     C-type functions need to be compiled with a C++ compiler.
3. Adds specific types to enable converting between RPC and API types
    
    This commit adds two generic templated types (managed_rpc_type<T> and
    unmanaged_rpc_type<T>) that simplify the lifetime management of any C-types
    created by Margo RPCs. They also offer conversion functions that allow
    converting between C RPC types and C++ API types.
    
    Both types internally create and store pointers to the C-structures required
    (or produced) by the RPC engine, but differ in how they manage these
    structures:
    
    - The `managed_rpc_type<T>` template internally manages the lifetime of the
      C underlying object and ensures that its destruction function will be
      called when the destructor for `managed_rpc_type<T>` is called.
    
    - The `unmanaged_rpc_type<T>` template only creates the C underlying
      object, but does not destroy it. This is useful when conversions
      are needed but the underlying data will be automatically destroyed by Margo.
    
    Specific conversions are implemented as template specializations. For
    example, `template <> struct admire::managed_rpc_type<admire::job>`
    allows converting from an `admire::job` instance to a newly-created `ADM_job_t`
    via its `get()` function. On the other hand,
    `template <> struct admire::managed_rpc_type<ADM_job_t>` allows converting
    from an existing `ADM_job_t` to an `admire::job` instance, also via its
    `get()` function.

Closes #25

See merge request !16