```python
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.cpp_extension import load_inline

_cpp_source = r"""
#include <torch/extension.h>
torch::Tensor fused_activations_cuda(torch::Tensor x, torch::Tensor add);
"""

_cuda_source = r"""
#include <torch/extension.h>
#include <ATen/cuda/CUDAContext.h>
#include <c10/cuda/CUDAGuard.h>
#include <c10/cuda/CUDAException.h>
#include <cuda_runtime.h>

__device__ __forceinline__ float activate(float x, float add) {
    x = x + add;
    x = x * (1.0f / (1.0f + expf(-x)));
    x = tanhf(x);
    x = (x * 0.5f) * (1.0f + erff(x * 0.7071067811865475244f));
    return fminf(1.0f, fmaxf(-1.0f, x));
}

__global__ void fused_scalar(
    const float* __restrict__ x,
    const float* __restrict__ add,
    float* __restrict__ output,
    int64_t count,
    int64_t width
) {
    const int64_t i =
        static_cast<int64_t>(blockIdx.x) * blockDim.x + threadIdx.x;
    if (i < count) {
        output[i] = activate(x[i], add[i % width]);
    }
}

__global__ void fused_vectorized(
    const float4* __restrict__ x,
    const float4* __restrict__ add,
    float4* __restrict__ output,
    int64_t count,
    int64_t width
) {
    const int64_t i =
        static_cast<int64_t>(blockIdx.x) * blockDim.x + threadIdx.x;
    if (i < count) {
        const float4 v = x[i];
        const float4 a = add[i % width];
        float4 result;
        result.x = activate(v.x, a.x);
        result.y = activate(v.y, a.y);
        result.z = activate(v.z, a.z);
        result.w = activate(v.w, a.w);
        output[i] = result;
    }
}

torch::Tensor fused_activations_cuda(torch::Tensor x, torch::Tensor add) {
    TORCH_CHECK(x.is_cuda() && add.is_cuda(), "Expected CUDA tensors");
    TORCH_CHECK(x.device() == add.device(), "Devices must match");
    TORCH_CHECK(x.scalar_type() == at::kFloat &&
                add.scalar_type() == at::kFloat, "Expected float32 tensors");
    TORCH_CHECK(x.is_contiguous() && add.is_contiguous(),
                "Expected contiguous tensors");
    TORCH_CHECK(x.dim() >= 1 && add.dim() == 1 &&
                x.size(-1) == add.numel(), "Invalid add shape");

    const c10::cuda::CUDAGuard guard(x.device());
    auto output = torch::empty_like(x);
    const int64_t count = x.numel();
    if (count == 0) {
        return output;
    }

    const int64_t width = add.numel();
    constexpr int threads = 256;
    const auto stream = at::cuda::getCurrentCUDAStream();

    const bool aligned =
        reinterpret_cast<uintptr_t>(x.data_ptr<float>()) % 16 == 0 &&
        reinterpret_cast<uintptr_t>(add.data_ptr<float>()) % 16 == 0;

    if (width % 4 == 0 && aligned) {
        const int64_t vectors = count / 4;
        fused_vectorized<<<(vectors + threads - 1) / threads, threads, 0, stream>>>(
            reinterpret_cast<const float4*>(x.data_ptr<float>()),
            reinterpret_cast<const float4*>(add.data_ptr<float>()),
            reinterpret_cast<float4*>(output.data_ptr<float>()),
            vectors,
            width / 4
        );
    } else {
        fused_scalar<<<(count + threads - 1) / threads, threads, 0, stream>>>(
            x.data_ptr<float>(),
            add.data_ptr<float>(),
            output.data_ptr<float>(),
            count,
            width
        );
    }
    C10_CUDA_KERNEL_LAUNCH_CHECK();
    return output;
}
"""

_fused_ops = load_inline(
    name="linear_swish_tanh_gelu_hardtanh_fused",
    cpp_sources=_cpp_source,
    cuda_sources=_cuda_source,
    functions=["fused_activations_cuda"],
    extra_cflags=["-O3"],
    extra_cuda_cflags=["-O3", "--fmad=false"],
    verbose=False,
)


class ModelNew(nn.Module):
    def __init__(self, in_features, out_features, add_value_shape):
        super().__init__()
        self.matmul = nn.Linear(in_features, out_features)
        self.add_value = nn.Parameter(torch.randn(add_value_shape))

    def forward(self, x):
        x = self.matmul(x)

        if (
            x.is_cuda
            and x.dtype == torch.float32
            and self.add_value.dtype == torch.float32
            and x.device == self.add_value.device
            and x.is_contiguous()
            and self.add_value.is_contiguous()
            and self.add_value.ndim == 1
            and self.add_value.numel() == x.shape[-1]
            and not (
                torch.is_grad_enabled()
                and (x.requires_grad or self.add_value.requires_grad)
            )
        ):
            return _fused_ops.fused_activations_cuda(x, self.add_value)

        x = x + self.add_value
        x = torch.sigmoid(x) * x
        x = torch.tanh(x)
        x = F.gelu(x)
        return F.hardtanh(x, min_val=-1, max_val=1)
```