I'm going to do this in steps so you can follow my train of thought:

1. Make it classy

First, I would wrap everything in a class. Functions that belong together go together in a class (unless you have a specific reason not to). This may feel a bit much when you're a beginner, but the more you do that, the more you understand why (its mostly in the details).

So lets make it a class:

class FirebaseExample{
    public function get_access_token ($service_account_key_file) {
        // your code
    }

    public function send_fcm_notification($server_key, $fcm_token, $title, $body) {
        // your code
    }
}

Typehinting

You should ALWAYS typehint. If you dont typehint, you can wiggle a bit with what you input, you get away with more sloppyness. But a lot of wiggle makes a bad construction. Also, php is camelCase, not snake_case. Lets apply that:

class FirebaseExample{
    public function getAccessToken (string $serviceAccountKeyFile): string
    {
        // your code
    }

    public function sendFcmNotification(
        string $serverKey, 
        string $fcmToken, 
        string $title, 
        string $body
    ): string {
        // your code
    }
}

2. Single Responsibility

A function should have one task. What 'a task' is is more of a feeling than an exact science, but I've done the first method for you as an example:

class FirebaseExample 
{
    // Because we have a class, we can define a const for it, no need to keep passing it
    // down to all functions.
    private const ACCESS_TOKEN_FILE_LOCATION = 'firebase-admin.json';

    public function getAccessToken() 
    {
        $serviceAccount = $this->getServiceAccount();
        $token = $this->getJwtData($serviceAccount['client_email']);
        $jwt = JWT::encode($token, $service_account['private_key'], 'RS256');

        $data = $this->getGoogleApiAccessTokenResult($jwt);

        return $data['access_token'];
    }

    private function getServiceAccount(): array
    {
        return json_decode(
            file_get_contents(self::ACCESS_TOKEN_FILE_LOCATION),
            true
        );
    }

    private function getJwtData(string $clientEmail): array
    {
        $now = time();

        return [
            'iss' => $clientEmail,
            'scope' => 'https://www.googleapis.com/auth/firebase.messaging',
            'aud' => 'https://oauth2.googleapis.com/token',
            'iat' => $now,
            'exp' => $now + 3600,
        ]
    }

    private function getGoogleApiAccessTokenResult(string $jwt): array
    {
        $ch = curl_init();
        curl_setopt($ch, CURLOPT_URL, 'https://oauth2.googleapis.com/token');
        curl_setopt($ch, CURLOPT_POST, true);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($ch, CURLOPT_POSTFIELDS, http_build_query([
            'grant_type' => 'urn:ietf:params:oauth:grant-type:jwt-bearer',
            'assertion' => $jwt,
        ]));

        $response = curl_exec($ch);
        curl_close($ch);

        return json_decode($response, true);
    }
}

Only the getAccessToken is public, other code may only call that method, not the others. Example:

$firebaseExample = new FirebaseExample();
$firebaseExample->getAccessToken(); // will give you a string, we know this because of the typehint
$firebaseExample->getServiceAccount(); // will error. The outside world has nothing to do with this function 'hide' it.

Each function now has a task. It handles on 'sub job' and only that. You try to keep them as pure as possible, eg not calling a function in a function in a function etc, but "do a trick, give back result".

And the getAccessToken also has one job: It delegates tasks to other functions (much a like a people manager). The 'higher' a function is in the chain, the more readable is should be, eg more english-y than code-y.

There is more room for improvement, also in my own examples, but the suggestions above would be a good step in the right direction. From there issues become less significant (IMO)