input: Write a python function to find the fastest path in a graph.
  assert find_fastest_path(graph, 3, 5) == (8, [3, 4, 5])
  assert find_fastest_path(graph, 3, 7) == (3, [3, 7])
  assert find_fastest_path(graph, 4, 5) == (3, [4, 5])
  assert find_fastest_path(graph, 5, 5) == (0, [5])
output: import heapq
  
  def find_fastest_path(graph, start, end):
      # Initialize the priority queue with the starting node and a path list
      priority_queue = [(0, start, [start])]
      # Dictionary to store the shortest distance to each node
      shortest_distances = {start: 0}
      
      while priority_queue:
          (current_distance, current_node, path) = heapq.heappop(priority_queue)
          
          # If we reached the end node, return the distance and path
          if current_node == end:
              return (current_distance, path)
          
          # Examine all neighbors of the current node
          for neighbor, weight in graph[current_node].items():
              distance = current_distance + weight
              
              # If we found a shorter path to the neighbor, update the priority queue and shortest distances
              if neighbor not in shortest_distances or distance < shortest_distances[neighbor]:
                  shortest_distances[neighbor] = distance
                  heapq.heappush(priority_queue, (distance, neighbor, path + [neighbor]))
      
      # If the end node is not reachable, return None
      return None