Asp.net networking/restclient layer

I thought that what you have is actually quite solid; my only suggestion is that you should take advantage of C#'s features in order to slightly clean things up. First, let's create an options object to hold the various items that you're injecting into the class:

public class HttpServiceOptions<TLogger>
{
    public string AuthenticationToken { get; set; }
    public ILogger<TLogger> Logger { get; set; }
}

This should make it much simpler to add/remove dependencies to the "system" since everything is injected via a single "container". Now, let's make your base class abstract and refactor it to accept our options object:

public abstract class AbstractHttpService<TLogger>
{
    private readonly string _authToken;
    private readonly HttpClient _client;

    public ILogger<TLogger> Logger { get; }

    public AbstractHttpService(HttpClient httpClient, IOptions<HttpServiceOptions<TLogger>> options) {
        var optionsValue = options.Value;
        var client = httpClient;

        client.BaseAddress = new Uri("url/");
        client.DefaultRequestHeaders.Add("Accept", "application/json");

        _authToken = optionsValue.AuthenticationToken;
        _client = client;

        Logger = optionsValue.Logger;
    }

    public async Task<FailureResponseModel> GetFailureResponseModel(HttpResponseMessage response) {
        var failureModel = await response.Content.ReadAsAsync<FailureResponseModel>();

        failureModel.ResponseStatusCode = Convert.ToInt32(response.StatusCode);

        Logger.LogError("Request Failed: {Error}", failureModel.ResultDetails);

        return failureModel;
    }
    public async Task<object> ProcessAsync<T>(HttpRequestMessage request, NamingStrategy namingStrategy) {
        var authToken = _authToken;

        if (!string.IsNullOrEmpty(authToken)) {
            request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", authToken);
        }

        var response = await _client.SendAsync(request);

        if (response.IsSuccessStatusCode) {
            Logger.LogInformation("Request Succeeded");

            var dezerializerSettings = new JsonSerializerSettings {
                ContractResolver = new DefaultContractResolver {
                    NamingStrategy = namingStrategy
                }
            };
            var responseModel = JsonConvert.DeserializeObject<T>(await response.Content.ReadAsStringAsync(), dezerializerSettings);

            return responseModel;
        }
        else {
            return await GetFailureResponseModel(response);
        }
    }
    public async Task<object> GetAsync<T>(string uri) {
        return await GetAsync<T>(uri, new DefaultNamingStrategy());
    }
    public async Task<object> GetAsync<T>(string uri, NamingStrategy namingStrategy) {
        using (var requestMessage = new HttpRequestMessage(HttpMethod.Get, uri)) {
            return await ProcessAsync<T>(requestMessage, namingStrategy);
        }
    }
    public async Task<object> PostAsync<T1, T2>(string uri, T2 content) {
        return await PostAsync<T1, T2>(uri, content, new DefaultNamingStrategy());
    }
    public async Task<object> PostAsync<T1, T2>(string uri, T2 content, NamingStrategy namingStrategy) {
        using (var requestMessage = new HttpRequestMessage(HttpMethod.Post, uri)) {
            var json = JsonConvert.SerializeObject(content);

            using (var stringContent = new StringContent(json, Encoding.UTF8, "application/json")) {
                requestMessage.Content = stringContent;
                return await ProcessAsync<T1>(requestMessage, namingStrategy);
            }
        }
    }
    public async Task<object> PutAsyc<T1, T2>(string uri, T2 content) {
        return await PutAsyc<T1, T2>(uri, content, new DefaultNamingStrategy());
    }
    public async Task<object> PutAsyc<T1, T2>(string uri, T2 content, NamingStrategy namingStrategy) {
        using (var requestMessage = new HttpRequestMessage(HttpMethod.Put, uri)) {
            var json = JsonConvert.SerializeObject(
                value: content,
                formatting: Formatting.None,
                settings: new JsonSerializerSettings {
                    NullValueHandling = NullValueHandling.Ignore
                }
            );

            using (var stringContent = new StringContent(json, Encoding.UTF8, "application/json")) {
                requestMessage.Content = stringContent;

                return await ProcessAsync<T1>(requestMessage, namingStrategy);
            }
        }
    }
}

We also need to implement the ClubMatasHttpService by deriving from the abstract class:

public sealed class ClubMatasHttpService : AbstractHttpService<ClubMatasHttpService>
{
    public ClubMatasHttpService(HttpClient httpClient, IOptions<HttpServiceOptions<ClubMatasHttpService>> options) : base(httpClient, options) { }

    public async Task<object> GetShops(string category) {
        Logger.LogInformation("ClubMatas outgoing request: {RequestName}", nameof(GetShops));

        return await GetAsync<ShopsResponseModel>($"v2/shops?category={WebUtility.UrlEncode(category)}");
    }
    public async Task<object> PostLogin(LoginRequestModel form) {
        Logger.LogInformation("ClubMatas outgoing request: {RequestName}", nameof(PostLogin));

        return await PostAsync<LoginResponseModel, LoginRequestModel>("v2/login", form, new SnakeCaseNamingStrategy());
    }
}

Finally, we write a couple of extension methods to help configure everything:

public static class IServiceCollectionExtensions
{
    public static IHttpClientBuilder AddClubMatasHttpService(this IServiceCollection services, Action<HttpServiceOptions<ClubMatasHttpService>> configureOptions) {
        if (null == services) { throw new ArgumentNullException(nameof(services)); }
        if (null == configureOptions) { throw new ArgumentNullException(nameof(configureOptions)); }

        services.Configure(configureOptions);

        return services.AddHttpClient<ClubMatasHttpService>();
    }
    public static IHttpClientBuilder AddClubMatasHttpService(this IServiceCollection services, IConfiguration configuration) {
        return services.AddClubMatasHttpService(configuration.Bind);
    }
}